synchronized

This version is the fewest lines of code, largely because the synchronization mechanism used is built into the language and runtime. But the programmer has to remember to avoid a couple of common bugs: The wait() must be inside a while instead of an if, and notifyAll() must be used instead of notify() because there are two different logical conditions being awaited.

   public class SafeBox<V> { private V value; public synchronized V get() throws InterruptedException { while (value == null) { wait(); } V result = value; value = null; notifyAll(); return result; } public synchronized void set(V newValue) throws InterruptedException { while (value != null) { wait(); } value = newValue; notifyAll(); } } 

ReentrantLock

This version is much more verbose than the synchronized version, and still suffers from the need for the programmer to remember to use while instead of if. However, one advantage is that we can introduce two separate Condition objects, which allows us to use signal() instead of signalAll(), which may be a performance benefit.

1   public class SafeBox<V> {
2     private final ReentrantLock lock = new ReentrantLock();
3     private final Condition valuePresent = lock.newCondition();
4     private final Condition valueAbsent = lock.newCondition();
5     private V value;
6
7     public V get() throws InterruptedException {
8       lock.lock();
9       try {
10         while (value == null) {
11           valuePresent.await();
12         }
13         V result = value;
14         value = null;
15         valueAbsent.signal();
16         return result;
17       } finally {
18         lock.unlock();
19       }
20     }
21
22     public void set(V newValue) throws InterruptedException {
23       lock.lock();
24       try {
25         while (value != null) {
26           valueAbsent.await();
27         }
28         value = newValue;
29         valuePresent.signal();
30       } finally {
31         lock.unlock();
32       }
33     }
34   }