why does the following code result in deadlock

Question

I have the following class

public class LockTester implements Runnable{
 private static Locker locker = new Locker();

 public static void main(String[] args){
  for(int i=0;i<10;i++){
   Thread t = new Thread(new LockTester());
   t.start();
  }
 }

 public void run(){
   for(int i=0;i<1000;i++){
    locker.unlockFirst();//note unlocking here
    locker.lockFirst();
    locker.lockSecond();
    locker.unlockSecond();
    locker.unlockFirst();
  }
 }
}

and Locker class

public class Locker{
 private Lock lock1 = new ReentrantLock();
 private Lock lock2 = new ReentrantLock();

 public void lockFirst(){
  lock1.lock();
 }
 public void lockSecond(){
  lock2.lock();
 }
 public void unlockFirst(){
  if(lock1.tryLock()){//note change
   lock1.unlock();
  }
 }
 public void unlockSecond(){
  lock2.unlock();
 }
}

Why does running this code result in deadlock.

Answer 1

lock1 is locked twice: once in lockFirst and again in unlockFirst ( lock1.tryLock() ), but unlocked only once in unlockFirst .

ReentrantLock has a hold count. See ReentrantLock . If you call tryLock, even if it's already held by the current thread it still increments the hold count. So, you increment it twice, but only decrement it once.

Answer 2

Having locked lock1 , you never fully unlock it . If the thread holds lock1 when it calls unlockFirst() , it will still hold lock1 when the function returns.

If you call lock1.lock() followed by a successful lock1.tryLock() , you need to call lock1.unlock() twice to completely release the lock. Your code doesn't do that, hence the deadlock.

Answer 3

You have a static Locker shared across all threads.

At some point a thread is going to try to tryLock() while the lock is already held by another thread.

edit: incorrect, ignore.