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.