How to release Java ReentrantLock after sometime no matter what

Question

My objective is to avoid thread deadlock or starvation. I have the following sample code for using ReentranLocks:

 class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...

   public void m1() { 
     lock.lock();  // block until condition holds
     try {
       // ... method body
       // ... start doing the calculations here ...
     } finally {
       //Do not release the lock here, instead, release it in m2()
     }
   }
   public void m2() { 
     try {
       // ... method body
       // ... continue doing the calculations here
     } finally {
       lock.unlock()
     }
   }

 }

I know I can use tryLock() with a timeout, but I am thinking also to ensure it will be unlocked no matter what as the lock will start in m1() and will be unlocked in m2(). How to ensure it will be unlocked say after 3 seconds no matter what, as soon as I start the lock in m1()?

For the above to be successful, ie. without sending unlock request after 3 seconds, the caller or the user of the JavaBean must ensure calling m1() and then m2() immediately. This is a restriction I want to avoid, and if the programmer forgets to do that, it might result in spending a long time troubleshooting this issue, which is, why the system is getting in a deadlock.

Thoughts:

I am thinking to use Scheduled Tasks and Timers, will that work?

Answer 1

Only the thread holding the lock may release it. That thread could track how long it has held the lock, and release it after the prescribed interval. Alternatively, another thread could wait for the prescribed interval, then signal the owner thread to stop its work and release the lock. This might be through interruption or another condition.

In either case, the lock-holding thread needs to be written to support the timeout mechanism, stop its work, and release the lock. Another thread can't forcibly revoke its lock.

---

You could do something hokey looking at the time the lock has been held. This has different failure modes that failing to unlock a real lock; I feel like it has more potential to cause damage, so I wouldn't use it personally, but I don't know your circumstances. (I would just log the lock() with a note to expect a corresponding unlock() log in order to aid troubleshooting, and then review my code carefully.)

Because the system time can have discontinuities and is not monotonic, the lock might be held (much) more or less than the specified time.

Here is an (untested) class intended to act like a lock that can only be held for a specified time:

final class PseudoLock {

    private final Object lock = new Object();

    private final Clock clock;

    private final long limit;

    private final TimeUnit unit;

    private Instant acquired;

    PseudoLock(Clock clock, long limit, TimeUnit unit) {
        this.clock = Objects.requireNonNull(clock);
        if (limit < 1) throw new IllegalArgumentException();
        this.limit = limit;
        this.unit = Objects.requireNonNull(unit);
    }

    void acquire() throws InterruptedException {
        synchronized (lock) {
            Instant now = Instant.now(clock);
            while (acquired != null) {
                long delay = limit - acquired.until(now, unit.toChronoUnit());
                if (delay > 0) {
                    unit.timedWait(lock, delay);
                    now = Instant.now(clock);
                } else {
                    break;
                }
            }
            acquired = now;
        }
    }

    void release() {
        synchronized (lock) {
            acquired = null;
            lock.notify();
        }
    }

}

You would use it like this:

class X {

   private final PseudoLock lock = 
     new PseudoLock(Clock.systemUTC(), 3L, TimeUnit.SECONDS);

   public void m1() { 
     lock.acquire();  // block until condition holds
     // ... method body
     // ... start doing the calculations here ...
   }

   public void m2() { 
     try {
       // ... method body
       // ... continue doing the calculations here
     } finally {
       lock.release();
     }
   }

}