目錄

1 併發包

2 併發佇列

1 併發包

1.1同步容器類

1.1.1Vector與ArrayList區別

1.1.1.1 ArrayList是最常用的List實現類，內部是通過陣列實現的，它允許對元素進行快速隨機訪問。陣列的缺點是每個元素之間不能有間隔，當陣列大小不滿足時需要增加儲存能力，就要講已經有陣列的資料複製到新的儲存空間中。當從ArrayList的中間位置插入或者刪除元素時，需要對陣列進行復制、移動、代價比較高。因此，它適合隨機查詢和遍歷，不適合插入和刪除。

1.1.1.2.Vector與ArrayList一樣，也是通過陣列實現的，不同的是它支援執行緒的同步

注意: Vector執行緒安全、ArrayList執行緒不安全

Vector原始碼類

Add方法原始碼類

    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
 

Arraylist原始碼

Add方法原始碼

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }

1.1.2HasTable與HasMap

1.1.2.1 HashMap不是執行緒安全的 

HashMap是一個介面 是map介面的子介面，是將鍵對映到值的物件，其中鍵和值都是物件，並且不能包含重複鍵，但可以包含重複值。HashMap允許null key和null value，而hashtable不允許。

1.1.2.2 HashTable是執行緒安全的一個Collection。

1.1.2.3 HashMap是Hashtable的輕量級實現（非執行緒安全的實現），他們都完成了Map介面，主要區別在於HashMap允許空（null）鍵值（key）,由於非執行緒安全，效率上可能高於Hashtable。
HashMap允許將null作為一個entry的key或者value，而Hashtable不允許。
HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。

注意: HashTable執行緒安全，HashMap執行緒不安全。

1.1.3 synchronizedMap

 Collections.synchronized*(m) 將執行緒不安全額集合變為執行緒安全集合

1.1.4 ConcurrentHashMap

ConcurrentMap介面下有倆個重要的實現 :
ConcurrentHashMap
ConcurrentskipListMap (支援併發排序功能。彌補ConcurrentHas hMa p)
ConcurrentHashMap內部使用段(Segment)來表示這些不同的部分，每個段其實就是一個
小的HashTable,它們有自己的鎖。只要多個修改操作發生在不同的段上，它們就可以並
發進行。把一個整體分成了16個段(Segment.也就是最高支援16個執行緒的併發修改操作。
這也是在重執行緒場景時減小鎖的粒度從而降低鎖競爭的一種方案。並且程式碼中大多共享變
量使用volatile關鍵字宣告，目的是第一時間獲取修改的內容，效能非常好。

1.1.5 CountDownLatch​​​​​​

 CountDownLatch類位於java.util.concurrent包下，利用它可以實現類似計數器的功能。比如有一個任務A，它要等待其他4個任務執行完畢之後才能執行，此時就可以利用CountDownLatch來實現這種功能

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(2);
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是子執行緒開始執行。。。。");
                try {
                    Thread.sleep(1000);//子執行緒處理事情
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();//每次減一
                System.out.println("我是子執行緒執行結束。。。。");
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("我是子執行緒開始執行。。。。");
                try {
                    Thread.sleep(1000);//子執行緒處理事情
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
                System.out.println("我是子執行緒執行結束。。。。");
            }
        }).start();
        countDownLatch.await();//如果不為0，則一直等待
        System.out.println("主執行緒開始執行任務");
        for (int i = 0; i < 10; i++) {
            System.out.println("main: i="+i);
        }
    }
}

1.1.6 CyclicBarrier

CyclicBarrier初始化時規定一個數目，然後計算呼叫了CyclicBarrier.await()進入等待的執行緒數。當執行緒數達到了這個數目時，所有進入等待狀態的執行緒被喚醒並繼續。

CyclicBarrier就如同他的名字一樣，可看成是一個障礙，所有的執行緒必須到齊後才能一起通過這個障礙。

CyclicBarrier初始時還可帶一個Runnable的引數，該Runnable任務在CyclicBarrier的數目達到後，所有其他的執行緒被喚醒前被執行。 

class Writer extends Thread{
    CyclicBarrier cyclicBarrier;
    public Writer(CyclicBarrier cyclicBarrier){
        this.cyclicBarrier=cyclicBarrier;
    }
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"開始寫入資料.....");
        try {
            Thread.sleep(1000);//模擬耗時
            System.out.println(Thread.currentThread().getName()+"寫入資料成功.....");
            cyclicBarrier.await();
            System.out.println(Thread.currentThread().getName()+"寫入資料完畢.....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (BrokenBarrierException e) {
            e.printStackTrace();
        }
    }
}
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier barrier = new CyclicBarrier(5);
        for (int i = 0; i < 5; i++) {
            new Writer(barrier).start();
        }
    }
}

輸出：
Thread-0開始寫入資料.....
Thread-1開始寫入資料.....
Thread-2開始寫入資料.....
Thread-3開始寫入資料.....
Thread-4開始寫入資料.....
Thread-0寫入資料成功.....
Thread-1寫入資料成功.....
Thread-2寫入資料成功.....
Thread-4寫入資料成功.....
Thread-3寫入資料成功.....
Thread-3寫入資料完畢.....
Thread-4寫入資料完畢.....
Thread-2寫入資料完畢.....
Thread-1寫入資料完畢.....
Thread-0寫入資料完畢.....
如果不加CyclicBarrier則：
Thread-0開始寫入資料.....
Thread-1開始寫入資料.....
Thread-2開始寫入資料.....
Thread-3開始寫入資料.....
Thread-4開始寫入資料.....
Thread-0寫入資料成功.....
Thread-0寫入資料完畢.....
Thread-1寫入資料成功.....
Thread-1寫入資料完畢.....
Thread-2寫入資料成功.....
Thread-2寫入資料完畢.....
Thread-3寫入資料成功.....
Thread-3寫入資料完畢.....
Thread-4寫入資料成功.....
Thread-4寫入資料完畢.....

1.1.6 Semaphore

Semaphore是一種基於計數的訊號量，它可以設定一個閾值，基於此，多個執行緒競爭獲取許可訊號，做自己的申請後歸還，超過閾值後，執行緒申請許可訊號將被阻塞。Semaphore可以用來構建一些物件池，資源池之類的，比如資料庫連線池，我們也可以建立計數為1的Semaphore,將其作為一種類似互斥鎖的機制，這也叫二元訊號量，表示兩種互斥狀態。用法如下：

availablePermits函式用來獲取當前可用的資源數量

wc.acquire();//申請資源

wc.release();//釋放資源

案例:

需求: 一個廁所只有3個坑位，但是有10個人來上廁所，那怎麼辦？假設10的人的編號分別為1-10，並且1號先到廁所，10號最後到廁所。那麼1-3號來的時候必然有可用坑位，順利如廁，4號來的時候需要看看前面3人是否有人出來了，如果有人出來，進去，否則等待。同樣的道理，4-10號也需要等待正在上廁所的人出來後才能進去，並且誰先進去這得看等待的人是否有素質，是否能遵守先來先上的規則。

class User extends Thread{
    Semaphore wc;
    String name;

    public User(Semaphore wc, String name) {
        this.wc = wc;
        this.name = name;
    }

    @Override
    public void run() {
        int availablePermits = wc.availablePermits();
        if(availablePermits>0){
            System.out.println(name+":天助我也，我有茅坑的喲");
        } else {
            System.out.println(name+":我靠，居然沒有茅坑了");
        }
        try {
            wc.acquire();
            System.out.println(name+":終於能上廁所了，倍兒爽！！！！");
            Thread.sleep(new Random().nextInt(1000));
            System.out.println(name+":廁所上完了");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            wc.release();
        }
    }
}
public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);//最多支援多少個執行緒
        for (int i = 1; i <= 10; i++) {
            new User(semaphore, i+"").start();
        }
    }
}

輸出如下：
1:天助我也，我有茅坑的喲
1:終於能上廁所了，倍兒爽！！！！
2:天助我也，我有茅坑的喲
2:終於能上廁所了，倍兒爽！！！！
3:天助我也，我有茅坑的喲
3:終於能上廁所了，倍兒爽！！！！
4:我靠，居然沒有茅坑了
5:我靠，居然沒有茅坑了
6:我靠，居然沒有茅坑了
7:我靠，居然沒有茅坑了
8:我靠，居然沒有茅坑了
9:我靠，居然沒有茅坑了
10:我靠，居然沒有茅坑了
1:廁所上完了
4:終於能上廁所了，倍兒爽！！！！
4:廁所上完了
5:終於能上廁所了，倍兒爽！！！！
2:廁所上完了
6:終於能上廁所了，倍兒爽！！！！
3:廁所上完了
7:終於能上廁所了，倍兒爽！！！！
7:廁所上完了
8:終於能上廁所了，倍兒爽！！！！
5:廁所上完了
9:終於能上廁所了，倍兒爽！！！！
6:廁所上完了
10:終於能上廁所了，倍兒爽！！！！
8:廁所上完了
10:廁所上完了
9:廁所上完了

2 併發佇列

在併發佇列上JDK提供了兩套實現，一個是以ConcurrentLinkedQueue為代表的高效能佇列，一個是以BlockingQueue介面為代表的阻塞佇列，無論哪種都繼承自Queue。

2.1 ConcurrentLinkedQueue

ConcurrentLinkedQueue:是一個適用於高併發場景下的佇列，通過無所的方式，實現了高併發狀態下的高效能，通常ConcurrentLinkedQueue效能好於BlockingQueue。他是一個基於連線節點的無界執行緒安全佇列。該佇列的執行緒遵循FIFO的原則，不允許null元素。

add 和offer() 都是加入元素的方法(在ConcurrentLinkedQueue中這倆個方法沒有任何區別)
poll() 和peek() 都是取頭元素節點，區別在於前者會刪除元素，後者不會。

2.2 BlockingQueue

阻塞佇列（BlockingQueue）是一個支援兩個附加操作的佇列。這兩個附加的操作是：

在佇列為空時，獲取元素的執行緒會等待佇列變為非空。

當佇列滿時，寫入（儲存）元素的執行緒會等待佇列可用。

在Java中，BlockingQueue的介面位於java.util.concurrent 包中(在Java5版本開始提供)，由上面介紹的阻塞佇列的特性可知，阻塞佇列是執行緒安全的。

在新增的Concurrent包中，BlockingQueue很好的解決了多執行緒中，如何高效安全“傳輸”資料的問題。通過這些高效並且執行緒安全的佇列類，為我們快速搭建高質量的多執行緒程式帶來極大的便利。本文詳細介紹了BlockingQueue家庭中的所有成員，包括他們各自的功能以及常見使用場景。

常用的佇列主要有以下兩種：（當然通過不同的實現方式，還可以延伸出很多不同型別的佇列，DelayQueue就是其中的一種）

　　先進先出（FIFO）：先插入的佇列的元素也最先出佇列，類似於排隊的功能。從某種程度上來說這種佇列也體現了一種公平性。

　　後進先出（LIFO）：後插入佇列的元素最先出佇列，這種佇列優先處理最近發生的事件。

      多執行緒環境中，通過佇列可以很容易實現資料共享，比如經典的“生產者”和“消費者”模型中，通過佇列可以很便利地實現兩者之間的資料共享。假設我們有若干生產者執行緒，另外又有若干個消費者執行緒。如果生產者執行緒需要把準備好的資料共享給消費者執行緒，利用佇列的方式來傳遞資料，就可以很方便地解決他們之間的資料共享問題。但如果生產者和消費者在某個時間段內，萬一發生資料處理速度不匹配的情況呢？理想情況下，如果生產者產出資料的速度大於消費者消費的速度，並且當生產出來的資料累積到一定程度的時候，那麼生產者必須暫停等待一下（阻塞生產者執行緒），以便等待消費者執行緒把累積的資料處理完畢，反之亦然。然而，在concurrent包釋出以前，在多執行緒環境下，我們每個程式設計師都必須去自己控制這些細節，尤其還要兼顧效率和執行緒安全，而這會給我們的程式帶來不小的複雜度。好在此時，強大的concurrent包橫空出世了，而他也給我們帶來了強大的BlockingQueue。（在多執行緒領域：所謂阻塞，在某些情況下會掛起執行緒（即阻塞），一旦條件滿足，被掛起的執行緒又會自動被喚醒）

2.3 ArrayBlockingQueue

ArrayBlockingQueue是一個有邊界的阻塞佇列，它的內部實現是一個數組。有邊界的意思是它的容量是有限的，我們必須在其初始化的時候指定它的容量大小，容量大小一旦指定就不可改變。

ArrayBlockingQueue是以先進先出的方式儲存資料，最新插入的物件是尾部，最新移出的物件是頭部。下面是一個初始化和使用ArrayBlockingQueue的例子：

2.4 LinkedBlockingQueue

LinkedBlockingQueue阻塞佇列大小的配置是可選的，如果我們初始化時指定一個大小，它就是有邊界的，如果不指定，它就是無邊界的。說是無邊界，其實是採用了預設大小為Integer.MAX_VALUE的容量 。它的內部實現是一個連結串列。

和ArrayBlockingQueue一樣，LinkedBlockingQueue 也是以先進先出的方式儲存資料，最新插入的物件是尾部，最新移出的物件是頭部。下面是一個初始化和使LinkedBlockingQueue的例子：

2.5 PriorityBlockingQueue

PriorityBlockingQueue是一個沒有邊界的佇列，它的排序規則和 java.util.PriorityQueue一樣。需要注意，PriorityBlockingQueue中允許插入null物件。

所有插入PriorityBlockingQueue的物件必須實現 java.lang.Comparable介面，佇列優先順序的排序規則就是按照我們對這個介面的實現來定義的。

另外，我們可以從PriorityBlockingQueue獲得一個迭代器Iterator，但這個迭代器並不保證按照優先順序順序進行迭代。

2.6 SynchronousQueue

SynchronousQueue佇列內部僅允許容納一個元素。當一個執行緒插入一個元素後會被阻塞，除非這個元素被另一個執行緒消費。

2.7 使用BlockingQueue模擬生產者與消費者

class ProducerThread extends Thread{
    private BlockingQueue queue;
    private volatile boolean flag=true;
    private static AtomicInteger count=new AtomicInteger();

    public ProducerThread(BlockingQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        System.out.println("生產者執行緒啟動。。。。。。。");
        try{
            while (flag){
                System.out.println("生產者正在生產佇列");
                String data=count.incrementAndGet()+"";
                //新增佇列
                boolean offer=queue.offer(data);
                if(offer){
                    System.out.println("生產者新增佇列"+data+"成功！");
                } else{
                    System.out.println("生產者新增佇列"+data+"失敗！");
                }
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println("生產者執行緒停止。。。。。。。。");
        }
    }
    public void stopThread(){
        this.flag=false;
    }
}

class ConsumerThread extends Thread{
    private BlockingQueue queue;
    private volatile boolean flag=true;
    private static AtomicInteger count=new AtomicInteger();

    public ConsumerThread(BlockingQueue queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        System.out.println("消費者執行緒啟動。。。。。。。");
        try{
            while (flag){
                //獲取完畢後，佇列會刪除頭元素
                String data = (String) queue.poll(2, TimeUnit.SECONDS);
                if(data!=null){
                    System.out.println("消費者獲取data："+data+"成功！");
                } else{
                    System.out.println("消費者獲取data失敗！");
                    this.flag=false;
                }
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println("消費者執行緒停止。。。。。。。。");
        }
    }
    public void stopThread(){
        this.flag=false;
    }
}
public class ProConDemo {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> queue=new LinkedBlockingQueue<>(10);
        ProducerThread p1=new ProducerThread(queue);
        ProducerThread p2=new ProducerThread(queue);

        ConsumerThread c1=new ConsumerThread(queue);
//        ConsumerThread c2=new ConsumerThread(queue);
        p1.start();
        p2.start();
        c1.start();
        Thread.sleep(10*1000);
        p1.stopThread();
        p2.stopThread();
    }

}


生產者執行緒啟動。。。。。。。
生產者正在生產佇列
生產者新增佇列1成功！
生產者執行緒啟動。。。。。。。
生產者正在生產佇列
生產者新增佇列2成功！
消費者執行緒啟動。。。。。。。
消費者獲取data：1成功！
生產者正在生產佇列
生產者新增佇列3成功！
生產者正在生產佇列
生產者新增佇列4成功！
消費者獲取data：2成功！
生產者正在生產佇列
生產者新增佇列5成功！
生產者正在生產佇列
生產者新增佇列6成功！
消費者獲取data：3成功！
生產者正在生產佇列
生產者新增佇列7成功！
生產者正在生產佇列
生產者新增佇列8成功！
消費者獲取data：4成功！
生產者正在生產佇列
生產者新增佇列9成功！
生產者正在生產佇列
生產者新增佇列10成功！
消費者獲取data：5成功！
生產者正在生產佇列
生產者新增佇列11成功！
生產者正在生產佇列
生產者新增佇列12成功！
消費者獲取data：6成功！
生產者正在生產佇列
生產者新增佇列13成功！
生產者正在生產佇列
生產者新增佇列14成功！
消費者獲取data：7成功！
生產者正在生產佇列
生產者新增佇列15成功！
生產者正在生產佇列
生產者新增佇列16成功！
消費者獲取data：8成功！
生產者正在生產佇列
生產者新增佇列17成功！
生產者正在生產佇列
生產者新增佇列18成功！
消費者獲取data：9成功！
生產者正在生產佇列
生產者新增佇列19成功！
生產者正在生產佇列
生產者新增佇列20失敗！
消費者獲取data：10成功！
生產者執行緒停止。。。。。。。。
生產者執行緒停止。。。。。。。。
消費者獲取data：11成功！
消費者獲取data：12成功！
消費者獲取data：13成功！
消費者獲取data：14成功！
消費者獲取data：15成功！
消費者獲取data：16成功！
消費者獲取data：17成功！
消費者獲取data：18成功！
消費者獲取data：19成功！
消費者獲取data失敗！
消費者執行緒停止。。。。。。。。