關於倒數鎖存器的實現

Question

我一直在瀏覽啓動三個線程的程序，並打印出相應的值，使得T3先執行，然後執行T1線程，最後執行T2線程。以下是該計劃。

我只是想知道，如果你們可以幫助轉換這個程序就倒計時閂鎖，因爲我想用這種機制來開發它，或者它也可以通過計數信號量來完成。

從answer to this related question：

public class Test { 
    static class Printer implements Runnable { 
    private final int from; 
    private final int to; 
    private Thread joinThread; 

    Printer(int from, int to, Thread joinThread) { 
     this.from = from; 
     this.to = to; 
     this.joinThread = joinThread; 
    } 

    @Override 
    public void run() { 
     if(joinThread != null) { 
     try { 
      joinThread.join(); 
     } catch (InterruptedException e) { /* ignore for test purposes */ } 
     } 
     for (int i = from; i <= to; i++) { 
     System.out.println(i); 
     } 
    } 
    } 
    public static void main(String[] args) throws InterruptedException { 

    Thread T3 = new Thread(new Printer(10, 15, null)); 
    Thread T1 = new Thread(new Printer(1, 5, T3)); 
    Thread T2 = new Thread(new Printer(6, 10, T1)); 
    T1.start(); 
    T2.start(); 
    T3.start(); 
    } 
} 

Answer 1

我們認爲每對線的Tw, Ts如Tw正在等待Ts開始工作。在你的設置中，有2對這樣的：

T1, T3 
T2, T1 

對於每一對，我們將創建一個CountDownLatch，並將其提供給對的每個線程。然後Tw將在開始工作之前在鎖存器上調用await，並且Ts將在其自己的工作結束時調用countDown。

由於T1屬於兩對，它將接收兩個鎖存器。但是，在第一種情況下，T1是一個等待線程，而第二種情況下，T1是一個信號線程，因此其代碼將不得不相應修改。

當然，你將不得不刪除join電話和相關的基礎設施。

由於您的問題標題詢問鎖實現，讓我們只簡單地說，相同的語義可以使用Semaphore初始化爲0，並在countDown實際上是信號的release生產，而await將是一個acquire那個信號量。

public class Test { 
    private CountdownLatch latch; 
    private Runnable runnable; 
    class Tw implements Runnable { 
    Tw(CountdownLatch l, Runnable r) { 
     latch = l; 
     runnable = r; 
    } 
    @override 
    public void run(){ 
     latch.await(); 
     runnable.run(); 
    } 
    } 

    class Ts implements Runnable { 
    CountdownLatch latch; 
    Runnable runnable; 
    Ts(CountdownLatch l, Runnable r){ 
     latch = l; 
     runnable = r; 
    } 
    @override 
    public void run(){ 
     runnable.run(); 
     latch.countDown(); 
    } 
    } 

    static class Printer implements Runnable { 
    private final int from; 
    private final int to; 

    Printer(int from, int to) { 
     this.from = from; 
     this.to = to; 
    } 

    @Override 
    public void run() { 
     for (int i = from; i <= to; i++) { 
      System.out.println(i); 
     } 
    } 

    public static void main(String[] args) throws InterruptedException { 
    CountdownLatch l31 = new CountdownLatch(1), l12 = new CountdownLatch(1);  
    Thread T3 = new Thread(new Ts(l31, new Printer(10, 15, null))); 
    Thread T1 = new Thread(new Tw(l31, new Ts(l12, new Printer(1, 5, T3)))); 
    Thread T2 = new Thread(new Tw(l12, new Printer(6, 10, T1))); 
    T1.start(); 
    T2.start(); 
    T3.start(); 
    } 
} 

提出的示例實現使用輔助可運行照顧閉鎖過程中，從而使我們利用這些可運行撰寫每一項任務，而不是導出Printer類爲每個特定的情況下（我們節省至少一類）。

基於Semaphore基於類似的實現留給讀者的練習。