轉換wait＆notifyAll代碼以使用Java 1.5 Lock對象

Question

我們使用的代碼在代碼片段周圍使用syncronized塊，並使用大量wait和notifyAll（）調用。我們試圖將這些轉換爲使用Java 5 Lock.lock（）和Lock.unlock（）方法。如何遷移此代碼以刪除所有wait和notifyAll調用。我不知道這些使用新的鎖定功能的等同物。

任何與例子的鏈接將不勝感激。

由於提前

當量，需要下面的代碼被轉換爲使用Lock.lock（）和lock.unlock第一部分以除去同步塊是簡單，因爲我只需要調用鎖（ ） 方法。問題是可以爲notifyAll（）和wait方法做些什麼。

 
    synchronized(LOCK) 
      { 
       while(!Thread.interrupted()) 
       { 
       try 
        { 

         working = runRules(); 

         if(!working) 
          LOCK.notifyAll(); 

         LOCK.wait(working ? shortTimeout : longTimeout); 
        } 
        catch(final InterruptedException e) 
        { 
         Package.log.info("Thread was interrupted. Exiting.", e); 
         return; 
        } 
       } 
      } 

Answer 1

使用Conditions provided by the java.util.concurrent.locks package：

final Object monitor = ... 

... 

synchronized (monitor) { 

    while (!condition) monitor.wait(); 
    ... do something ... 
} 

變爲：

final ReentrantLock lock = ...; 
final Condition cvar = lock.newCondition(); 

... 

lock.lock(); 

try { 

    while (!condition) cvar.await(); 
    ... do something ... 

} finally { 

    lock.unlock(); 
} 

信令側是非常相似：

synchronized (monitor) { 

     ... do something ... 
     monitor.notify(); 
} 

變爲：

由 Lock.newCondition()工廠方法提供個

lock.lock(); 

try { 

    ... do something ... 
    cvar.signalAll(); 

} finally { 

    lock.unlock(); 
} 

Answer 2

使用Condition對象。對象監視器的等待和通知方面被分解到這個接口中。

從一個遷移點：

• wait() - >await()
• wait(long) - >await(long, TimeUnit.Millis)或awaitNanos(long * 10000000)
• notify() - >signal()
• notifyAll() - >signalAll()

但是，條件比監視器在幾個方面更強大。首先它們更加細膩，因此對於不同的事物可以有多種條件。如果我有一個有限的阻塞集合的例子，我可以有一個滿的條件和一個空的條件，並等待和分別通知這些元素添加或刪除。

還有另外的await變種，允許您等待而不被打斷並等待某個特定的日期（時間）。

Condition類的javadocs非常好，並且非常詳細地描述它以及它的使用。

Answer 3

由於這個問題是在談論notifyAll，我已經嘗試了一些使用相位器的生產者/消費者的例子。我沒有使用鎖，因爲它需要嘗試/最後，條件對象，直到解鎖其他線程不會工作...等等...

import java.util.concurrent.Phaser; 

public class ProducerConsumerExample { 

    Phaser producer; 
    Phaser consumers; 
    volatile String array[]; 

    public void init() { 
     producer = new Phaser(5); 
     consumers = new Phaser(5); 
     Consumer l1 = new Consumer("Consumer_1"); 
     l1.setDaemon(true); 
     l1.start(); 
     Consumer l2 = new Consumer("Consumer_2"); 
     l2.setDaemon(true); 
     l2.start(); 
     Consumer l3 = new Consumer("Consumer_3"); 
     l3.setDaemon(true); 
     l3.start(); 
     Consumer l4 = new Consumer("Consumer_4"); 
     l4.setDaemon(true); 
     l4.start(); 
    } 

    class Consumer extends Thread { 

     Consumer(String name) { 
      super(name); 
     } 

     private void printMethod(String i) { 
      System.out.println(Thread.currentThread().getName() + " " + i); 
     } 

     public void run() { 
      while (true) { 
       //make the consumers sleep till producer produces 
       consumers.arriveAndAwaitAdvance(); 
       for (int i = 0; i < array.length; i++) { 
        printMethod(array[i]); 
       } 
       //alert the producer to start 
       producer.arriveAndAwaitAdvance(); 
       System.out.println(Thread.currentThread().getName() + " thread wakeup but will stuck with consumers.arriveAndAwaitAdvance!"); 

      } 
     } 
    } 

    public void run() { 
     for (int j = 0; j < 3; j++) { 
      array = new String[5]; 
      for (int i = 0; i < array.length; i++) { 
       array[i] = "Phase_" + (j + 1) + " Count_" + (i + 1); 
      } 
      System.out.println("Main thread pushed data."); 
      //alert the consumers to start 
      consumers.arriveAndAwaitAdvance(); 

      //make the producer sleep till all the consumer consumes 
      producer.arriveAndAwaitAdvance(); 
      System.out.println("Main thread wakeup and will start pushing data..."); 

     } 
    } 

    public static void main(String[] args) { 
     ProducerConsumerExample sch = new ProducerConsumerExample(); 
     sch.init(); 
     sch.run(); 
     System.out.println("Main thread completed, producing data."); 
    } 
}