java併發：線程同步機制之計數器&Exechanger

第一節 CountDownLatch

（1）初識CountDownLatch

 

（2）詳述CountDownLatch

　　CountDownLatch是經過一個計數器來實現的，計數器的初始值爲線程的數量。每當一個線程完成了本身的任務後，計數器的值就會減1，當計數器值到達0時，它表示全部的線程已經完成了任務，而後在閉鎖上等待的線程就能夠恢復執行任務。

CountDownLatch中主要方法以下：

　　public CountDownLatch(int count)，構造函數中的count（計數器）實際上就是閉鎖須要等待的線程數量，這個值只能被設置一次，並且CountDownLatch沒有提供任何機制去從新設置這個計數值。

 　　public void countDown()，每調用一次這個方法，在構造函數中初始化的count值就減1，通知機制是此方法來完成的。

 　　public void await() throws InterruptedException，調用此方法的當前線程會一直阻塞，直到計時器的值爲0。

 

（3）CountDownLatch示例

package com.test;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo{
    
    public static void main(String args[]) throws Exception{
        CountDownLatch latch = new CountDownLatch(3);
        Worker worker1 = new Worker("Jack 程序員1",latch);
        Worker worker2 = new Worker("Rose 程序員2",latch);
        Worker worker3 = new Worker("Json 程序員3",latch);
        worker1.start();
        worker2.start();
        worker3.start();
        
        latch.await();
        System.out.println("Main thread end!");
    }
    
    static class Worker extends Thread {
        private String workerName;
        private CountDownLatch latch;
        public Worker(String workerName,CountDownLatch latch) {
            this.workerName = workerName;
            this.latch = latch;
        }
        @Override
        public void run() {
            try {
                System.out.println("Worker:"+workerName +" is begin.");
                Thread.sleep(1000L);
                System.out.println("Worker:"+workerName +" is end.");
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }//模仿幹活；
            latch.countDown();
        }
    }
}

上述程序運行結果以下：

Worker:Rose 程序員2 is begin.
Worker:Json 程序員3 is begin.
Worker:Jack 程序員1 is begin.
Worker:Jack 程序員1 is end.
Worker:Json 程序員3 is end.
Worker:Rose 程序員2 is end.
Main thread end!

從結果上能夠看出，MainThread執行到latch.await();處會阻塞在該處，直到三個線程均完成的時候MainThread纔會繼續往下執行 

 

（4）參考資料

本小節只是簡單描述了CountDownLatch的使用方式等，欲瞭解其實現機制，能夠查看下面的幾篇文章

A、http://blog.itpub.net/30024515/viewspace-1432825/

B、http://www.tuicool.com/articles/mQnAfq

 

第二節 CyclicBarrier

（1）初識CyclicBarrier

 

（2）CyclicBarrier示例

應用場景：在某種需求中，好比一個大型的任務，經常須要分配不少子任務去執行，只有當全部子任務都執行完成時候，才能執行主任務，這時候就能夠選擇CyclicBarrier了。

示例：

package com.test;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierDemo{
    
    public static void main(String args[]) throws Exception{
        
        CyclicBarrier barrier = new CyclicBarrier(3,new TotalTask());
        
        BillTask worker1 = new BillTask("111",barrier);
        BillTask worker2 = new BillTask("222",barrier);
        BillTask worker3 = new BillTask("333",barrier);
        worker1.start();
        worker2.start();
        worker3.start();
        System.out.println("Main thread end!");
    }
    
    static class TotalTask extends Thread { public void run() {
            System.out.println("全部子任務都執行完了，就開始執行主任務了。");
        }
    }
    
    static class BillTask extends Thread {
        private String billName;
        private CyclicBarrier barrier;
        public BillTask(String workerName,CyclicBarrier barrier) {
            this.billName = workerName;
            this.barrier = barrier;
        }
        @Override
        public void run() {
            try {
                System.out.println("市區:"+billName +"運算開始：");
                Thread.sleep(1000L);//模仿第一次運算；
                System.out.println("市區:"+billName +"運算完成，等待中...");
                barrier.await();//假設一次運算不完，第二次要依賴第一次的運算結果。都到達這個節點以後後面纔會繼續執行；
                System.out.println("所有都結束，市區"+billName +"纔開始後面的工做。");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }
    
}

上述程序運行結果以下：

市區:111運算開始：
市區:333運算開始：
Main thread end! 市區:222運算開始： 市區:333運算完成，等待中... 市區:222運算完成，等待中... 市區:111運算完成，等待中... 全部子任務都執行完了，就開始執行主任務了。//這句話是最後到達wait()方法的那個線程執行的 所有都結束，市區111纔開始後面的工做。 所有都結束，市區222纔開始後面的工做。 所有都結束，市區333纔開始後面的工做。

解說：在這個示例中，構造CyclicBarrier時，傳入了內部類TotalTask（TotalTask繼承了Thread，是Runnable的實現）的實例對象，其意義在於：當全部的線程都執行到wait()方法時，它們會一塊兒返回繼續本身的工做，可是最後一個到達wait()方法的線程會執行TotalTask的run()方法；若是在構造構造CyclicBarrier時沒有傳入Runnable的實現對象做爲構造參數，則當全部的線程都執行到wait()方法時會直接一塊兒返回繼續本身的工做。

 

（3）CyclicBarrier與CountDownLatch的區別

A、CountDownLatch的做用是容許1或N個線程等待其餘線程完成執行；而CyclicBarrier則是容許N個線程相互等待；
B、CountDownLatch的計數器沒法被重置；而CyclicBarrier的計數器能夠被重置後使用，所以它被稱爲是循環的barrier。

 

 

第三節 Semaphore

（1）初識Semaphore

　　Java中的Semaphore用於在線程間傳遞信號，從概念上講，信號量維護了一個許可集合，Semaphore只對可用的許可進行計數，並採起相應的行動。信號量經常用於多線程的代碼中，好比數據庫鏈接池。

 

（2）Semaphore示例

場景：假設一個服務器資源有限，任意某一時刻只容許3我的同時進行訪問，這時一共來了10我的

package com.test;
import java.util.concurrent.Semaphore;
public class SemaphoreDemo{
    
    public static void main(String args[]) throws Exception{
        
        final Semaphore semaphore = new Semaphore(3);//一次只運行3我的進行訪問
        
        for(int i=0;i<10;i++) {
            final int no = i;
            Runnable thread = new Runnable() {
                public void run (){
                    try {
                        System.out.println("用戶"+no+"鏈接上了:");
                        Thread.sleep(300L);
                        semaphore.acquire();//獲取接下去執行的許可
                        System.out.println("用戶"+no+"開始訪問後臺程序...");
                        Thread.sleep(1000L);//模仿用戶訪問服務過程
                        semaphore.release();//釋放容許下一個線程訪問進入後臺
                        System.out.println("用戶"+no+"訪問結束。");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            };
            new Thread(thread).start();
        }
        
        System.out.println("Main thread end!");
    }
}

上述代碼運行結果以下：

用戶1鏈接上了:
用戶3鏈接上了:
用戶4鏈接上了:
用戶2鏈接上了:
用戶0鏈接上了:
用戶5鏈接上了:
用戶7鏈接上了:
Main thread end!
用戶6鏈接上了:
用戶8鏈接上了:
用戶9鏈接上了:
用戶3開始訪問後臺程序...
用戶4開始訪問後臺程序...
用戶2開始訪問後臺程序...
用戶4訪問結束。
用戶3訪問結束。
用戶7開始訪問後臺程序...
用戶0開始訪問後臺程序...
用戶8開始訪問後臺程序...
用戶2訪問結束。
用戶5開始訪問後臺程序...
用戶0訪問結束。
用戶7訪問結束。
用戶1開始訪問後臺程序...
用戶8訪問結束。
用戶6開始訪問後臺程序...
用戶1訪問結束。
用戶9開始訪問後臺程序...
用戶5訪問結束。
用戶6訪問結束。
用戶9訪問結束。

從結果上能夠看出來，10我的同時進來，可是隻能同時3我的訪問資源，釋放一個容許進來一個

 

（3）參考資料

http://ifeve.com/semaphore/

 

第四節 Exchanger

（1）初識Exchanger

此處的Exechanger與前面描述的幾個同步機制不同，前面描述的幾個同步機制均是經過計數器來實現的，下面簡單描述一下Exechanger，看看Exchanger的應用場景：

注意：從上文描述，咱們知道Exchanger用於在成對出現的線程之間（兩個線程共有一個Exchanger）交換數據

 

（2）Exechanger示例

            

 

（3）參考資料

http://www.cnblogs.com/davidwang456/p/4179488.html