Fix deadlock on releasing locks

Author: Tobias Hafner

dbms/src/main/java/org/polypheny/db/transaction/deadlocks/DeadlockHandler.java

@@ -25,7 +25,6 @@
 import org.polypheny.db.transaction.DeadlockDetectorType;
 import org.polypheny.db.transaction.Transaction;
 import org.polypheny.db.transaction.locking.Lockable;
-import org.polypheny.db.transaction.locking.S2plLockingLevel;
 import org.polypheny.db.util.DeadlockException;
 
 public class DeadlockHandler {
@@ -36,8 +35,8 @@ public class DeadlockHandler {
     private final DeadlockResolver deadlockResolver;
 
     private final ReentrantReadWriteLock concurrencyLock = new ReentrantReadWriteLock();
-    private final Lock sharedLock = concurrencyLock.readLock();
-    private final Lock exclusiveLock = concurrencyLock.writeLock();
+    private final Lock readLock = concurrencyLock.readLock();
+    private final Lock writeLock = concurrencyLock.writeLock();
 
     static {
         DeadlockDetectorType deadlockDetectorType = (DeadlockDetectorType) RuntimeConfig.S2PL_DEADLOCK_DETECTOR_TYPE.getEnum();
@@ -56,33 +55,27 @@ private DeadlockHandler(DeadlockDetector deadlockDetector, DeadlockResolver dead
         this.deadlockResolver = deadlockResolver;
     }
 
-    public void addAndResolveDeadlock(@NonNull Lockable lockable, @NonNull Transaction transaction, @NonNull Set<Transaction> owners ) {
-        sharedLock.lock();
+    public void addAndResolveDeadlock(@NonNull Lockable lockable, @NonNull Transaction transaction, @NonNull Set<Transaction> owners) {
+        writeLock.lock();
         try {
-            deadlockDetector.add(lockable, transaction, owners );
-            exclusiveLock.lock();
+            deadlockDetector.add(lockable, transaction, owners);
             List<Transaction> conflictingTransactions = deadlockDetector.getConflictingTransactions();
-            exclusiveLock.unlock();
-            // lock can be release here as concurrently adding or removing transactions does not affect the resolution process
-            while ( !conflictingTransactions.isEmpty() ) {
-                deadlockResolver.resolveDeadlock( conflictingTransactions );
-                exclusiveLock.lock();
+            while (!conflictingTransactions.isEmpty()) {
+                deadlockResolver.resolveDeadlock(conflictingTransactions);
                 conflictingTransactions = deadlockDetector.getConflictingTransactions();
-                exclusiveLock.unlock();
-                // lock can be release here as concurrently adding or removing transactions does not affect the resolution process
             }
         } finally {
-            sharedLock.unlock();
+            writeLock.unlock();
         }
     }
 
 
     public void remove(@NonNull Lockable lockable, @NonNull Transaction transaction ) {
-        sharedLock.lock();
+        readLock.lock();
         try {
             deadlockDetector.remove(lockable, transaction );
         } finally {
-            sharedLock.unlock();
+            readLock.unlock();
         }
     }
 

dbms/src/main/java/org/polypheny/db/transaction/locking/LockableImpl.java

@@ -74,7 +74,7 @@ private void upgradeToExclusive( Transaction transaction ) throws InterruptedExc
             }
             long count = owners.remove( transaction );
             while ( !owners.isEmpty() ) {
-                DeadlockHandler.INSTANCE.addAndResolveDeadlock(this, transaction, owners.keySet() );
+                //DeadlockHandler.INSTANCE.addAndResolveDeadlock(this, transaction, owners.keySet() );
                 concurrencyCondition.await();
             }
             isExclusive = true;
@@ -85,26 +85,25 @@ private void upgradeToExclusive( Transaction transaction ) throws InterruptedExc
     }
 
 
-    public void release( @NotNull Transaction transaction ) {
+    public void release(@NotNull Transaction transaction) {
         concurrencyLock.lock();
         try {
-            if ( isExclusive ) {
+            if (isExclusive) {
                 owners.clear();
                 isExclusive = false;
             }
-            // this decrements the entry if > 1 else it is removed
-            owners.computeIfPresent( transaction, ( key, value ) -> {
+            owners.computeIfPresent(transaction, (key, value) -> {
                 long newValue = value - 1;
                 return newValue <= 0 ? null : newValue;
-            } );
-            DeadlockHandler.INSTANCE.remove( this, transaction );
+            });
+            DeadlockHandler.INSTANCE.remove(this, transaction);
             concurrencyCondition.signalAll();
-            printAcquiredInfo( "R", transaction );
+            printAcquiredInfo("R", transaction);
         } finally {
             concurrencyLock.unlock();
         }
-        if ( !isRoot() ) {
-            parent.release( transaction );
+        if (!isRoot()) {
+            parent.release(transaction);
         }
     }
 
@@ -136,7 +135,6 @@ private void acquireShared( Transaction transaction ) throws InterruptedExceptio
         } finally {
             concurrencyLock.unlock();
         }
-
     }