Previously we saw some of the building blocks of concurrency in Java. In this blog we will focus on ReentRantLock. ReentRantLock is based on the AbstractQueuedSynchronizer.
By using the ReentRantLock we allow a thread to acquire a lock and use it multiple times. As the name suggests is provides us with Reentrancy just like the synchronized blocks.
Because ReentRantLock is implemented using the AbstractQueuedSynchronizer we can have fairness. The threads that try to acquire the lock will wait in a FIFO fashion and the algorithm will try to ensure fairness.
If we check our previous blog on locks we can see that locks are featureful.
If a thread holds the lock we cannot unlock it, only that thread is able to unlock it:
@Test
void alreadyAcquired() throws Exception {
final ReentrantLock reentrantLock = new ReentrantLock();
Thread thread = new Thread(() -> {
log.info("Try first time");
reentrantLock.lock();
log.info("Got the lock");
});
thread.start();
thread.join();
assertThrows(IllegalMonitorStateException.class, reentrantLock::unlock);
}Also as the name suggests let’s see the reentrancy. In the following example the same thread will try to get the lock it holds multiple times.
@Test
void reentrancy() throws Exception {
final ReentrantLock reentrantLock = new ReentrantLock();
Thread thread = new Thread(() -> {
log.info("Try first time");
reentrantLock.lock();
log.info("Got the lock");
log.info("lock one more time");
reentrantLock.lock();
log.info("locked again");
reentrantLock.unlock();
});
thread.start();
thread.join();
}In the next example we will construct a ReentRantLock with fairness enabled. Let’s do a small test on ReentRantLock’s of fairness.
5 threads will try to acquire the lock simultaneously. Then we will see how they achieved so and their order on acquiring the lock.
@AllArgsConstructor
private class CheckFairnessRunnable implements Runnable {
private final int sleepTime;
private final Lock lock;
@Override
public void run() {
try {
Thread.sleep(sleepTime);
log.info("acquiring lock");
lock.lock();
log.info("lock acquired");
Thread.sleep(5000);
lock.unlock();
log.info("lock unlocked");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
@Test
void fairness() throws Exception {
int numberOfThreads = 5;
ExecutorService executor = Executors.newFixedThreadPool(numberOfThreads);
final ReentrantLock reentrantLock = new ReentrantLock(true);
for (int i = 0; i < numberOfThreads; i++) {
Runnable runnable = new CheckFairnessRunnable(i*100, reentrantLock);
executor.execute(runnable);
}
executor.shutdown();
executor.awaitTermination(60, TimeUnit.SECONDS);
}If we examine the code and the CheckFairnessRunnable the thread initially sleeps. This is done on purpose so threads don’t arrive at the lock at the same time. The time a thread spends when it acquires the lock is high on purpose so we make sure all threads will wait for the lock.
Let’s check the output:
09:07:43.782 [pool-1-thread-1] INFO com.gkatzioura.concurrency.lock.ReentrantLockTest - acquiring lock 09:07:43.788 [pool-1-thread-1] INFO com.gkatzioura.concurrency.lock.ReentrantLockTest - lock acquired 09:07:43.882 [pool-1-thread-2] INFO com.gkatzioura.concurrency.lock.ReentrantLockTest - acquiring lock 09:07:43.985 [pool-1-thread-3] INFO com.gkatzioura.concurrency.lock.ReentrantLockTest - acquiring lock 09:07:44.085 [pool-1-thread-4] INFO com.gkatzioura.concurrency.lock.ReentrantLockTest - acquiring lock 09:07:44.185 [pool-1-thread-5] INFO com.gkatzioura.concurrency.lock.ReentrantLockTest - acquiring lock 09:07:48.797 [pool-1-thread-2] INFO com.gkatzioura.concurrency.lock.ReentrantLockTest - lock acquired 09:07:48.796 [pool-1-thread-1] INFO com.gkatzioura.concurrency.lock.ReentrantLockTest - lock unlocked 09:07:53.802 [pool-1-thread-3] INFO com.gkatzioura.concurrency.lock.ReentrantLockTest - lock acquired 09:07:53.802 [pool-1-thread-2] INFO com.gkatzioura.concurrency.lock.ReentrantLockTest - lock unlocked 09:07:58.807 [pool-1-thread-4] INFO com.gkatzioura.concurrency.lock.ReentrantLockTest - lock acquired 09:07:58.806 [pool-1-thread-3] INFO com.gkatzioura.concurrency.lock.ReentrantLockTest - lock unlocked 09:08:03.813 [pool-1-thread-5] INFO com.gkatzioura.concurrency.lock.ReentrantLockTest - lock acquired 09:08:03.813 [pool-1-thread-4] INFO com.gkatzioura.concurrency.lock.ReentrantLockTest - lock unlocked 09:08:08.819 [pool-1-thread-5] INFO com.gkatzioura.concurrency.lock.ReentrantLockTest - lock unlocked
We can see that the threads that were first to try to acquire the lock were also the ones that got the lock, so essentially the order was preserved.
That’s it on the next blogS we will check on more usages of locks and ReentRantLock.
Published on Java Code Geeks with permission by Emmanouil Gkatziouras, partner at our JCG program. See the original article here: Java Concurrency: ReentRantLock Fairness Opinions expressed by Java Code Geeks contributors are their own. |
