View difference between Paste ID: U9hVnjzQ and Vcccnu2L

-//---------------------------------
+package com.example.foo;
-Object lock = new Object();
+
-//Thread A:
+import java.util.concurrent.locks.Condition;
-synchronized(lock) {
+import java.util.concurrent.locks.Lock;
- lock.notifyAll();
+import java.util.concurrent.locks.ReentrantLock;
- runBeforeThreadBisNotified();
+
-}
+public class LockingDemo {
-//-----
+
-//Thread B:
+/* What I get:
-synchronized(lock) {
+
- lock.wait();
+TEST 1: notify/wait
- runOnNotificationFromThreadA();
+Thread notifyB will wait...
-}
+Thread notifyA notifies all.
-//---------------------------------
+Thread notifyA: code after notifyAll()
 ... Thread notifyB is awaken.
- final Lock lock = new ReentrantLock();
+Thread notifyB: code after wait()
- final Condition cond = lock.newCondition();
+TEST 2: signal/await
-//Thread A:
+Thread signalB will await...
- lock.lock();
+Thread signalA signals all.
- try {
+Thread signalA: code after signalAll()
-  cond.signal();
+... Thread signalB is awaken.
-  runWhenThreadBisFinished() ;
+Thread signalB: code after await()
- } finally {
+End of Test.
- lock.unlock();
+
- }
+*/
-//-----
+  public static final void sleep() {
-//Thread B:
+    try {
- lock.lock();
+      Thread.sleep(500);
- try {
+    } catch (InterruptedException e) {
-  cond.await();
+      System.err.println("Interrupted!");
-  runWhenSignaled() ;
+      Thread.currentThread().interrupt();
- } finally {
+    }
- lock.unlock();
+  }
- }
+
-//---------------------------------
+  public static void main(String[] args) throws InterruptedException {
 
     final Lock monitor = new ReentrantLock(true);
     final Condition cond1 = monitor.newCondition();
 
     final Thread notifyA = new Thread(new Runnable() {
 
       public void run() {
         sleep();
         synchronized (monitor) {
           System.out.println("Thread notifyA notifies all.");
           monitor.notifyAll();
           sleep();
           System.out.println("Thread notifyA: code after notifyAll()");
         }//now notifyB can really be awaken.
       }
     });
 
     final Thread notifyB = new Thread(new Runnable() {
 
       public void run() {
         synchronized (monitor) {
           try {
             System.out.println("Thread notifyB will wait...");
             monitor.wait();
             System.out.println("... Thread notifyB is awaken.");
             sleep();
             System.out.println("Thread notifyB: code after wait()");
           } catch (InterruptedException e) {
             e.printStackTrace();
             Thread.currentThread().interrupt();
           }
         }
       }
 
     });
     System.out.println("TEST 1: notify/wait");
     notifyB.start();
     notifyA.start();
     notifyB.join();
     notifyA.join();
     sleep();
     System.out.println("TEST 2: signal/await");
 
     final Thread signalA = new Thread(new Runnable() {
 
       public void run() {
         sleep();
         monitor.lock();
         try {
           System.out.println("Thread signalA signals all.");
           cond1.signalAll();
           sleep();
           System.out.println("Thread signalA: code after signalAll()");
         } finally {
           monitor.unlock(); //now signalB can really be awaken.
         }
       }
     });
 
     final Thread signalB = new Thread(new Runnable() {
 
       public void run() {
 
         monitor.lock();
           try {
             System.out.println("Thread signalB will await...");
             cond1.await();
             System.out.println("... Thread signalB is awaken.");
             sleep();
             System.out.println("Thread signalB: code after await()");
           } catch (InterruptedException e) {
             e.printStackTrace();
             Thread.currentThread().interrupt();
           } finally {
             monitor.unlock();
           }
         }
 
     });
 
     signalB.start();
     signalA.start();
     signalB.join();
     signalA.join();
     sleep();
 
     System.out.println("End of Test.");
   }
 
 }