Java的一些並發包

同步容器類

Vector和ArayList：

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

        Vector與ArrayList一樣，也是通過數組實現的，不同的是它支持線程的同步，即某一時刻只有一個線程能夠寫Vector，避免多線程同時寫而引起的不一致性，但實現同步需要很高的花費，因此，訪問它比訪問ArrayList慢。Vector與ArrayList的擴容並不一樣，Vector默認擴容是增長一倍的容量，Arraylist是增長50%的容量

注意: Vector線程安全、ArrayList

Vector.add源碼：

                      ​

ArrayList.add源碼：

                 ​

由此，看出，Vectory方法使用synchronized同步函數方法寫的，線程同步。

HashMap和HashTable：

1.HashMap不是線程安全的 ，HastMap是一個接口 是map接口的子接口，是將鍵映射到值的對象，其中鍵和值都是對象，並且不能包含重復鍵，但可以包含重復值。HashMap允許null key和null value，而hashtable不允許。

2.HashTable是線程安全的一個Collection。

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

注意: HashTable線程安全，HashMap線程不安全。HashTable的put方法源碼中也使用synchronized同步方法實現的

synchronizedMap

      源碼中使用同步代碼塊，將線程不安全額集合變為線程安全集合

      例： Collections.synchronizedMap(HashMap),將HashMap變成線程同步

ConcurrentHashMap

      ConcurrentMap接口下有倆個重要的實現 :

1. ConcurrentHashMap
2. ConcurrentskipListMap (支持並發排序功能。彌補ConcurrentHas hMa p)

      ConcurrentHashMap內部使用段(Segment)來表示這些不同的部分，每個段其實就是一個小的HashTable,它們有自己的鎖。只要多個修改操作發生在不同的段上，它們就可以並發進行。把一個整體分成了16個段(Segment.也就是最高支持16個線程的並發修改操作。這也是在重線程場景時減小鎖的粒度從而降低鎖競爭的一種方案。並且代碼中大多共享變量使用volatile關鍵字聲明，目的是第一時間獲取修改的內容，性能非常好。（在java8之后，摒棄了Segment的概念，改為用CAS算法）

ConcurrentHashMap方法是明顯效率要由於synchronizedMap的

 

CountDownLatch

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

public class Test002 {

    public static void main(String[] args) throws InterruptedException {
        System.out.println("等待子線程執行完畢...");
        CountDownLatch countDownLatch = new CountDownLatch(2);
        new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println("子線程," + Thread.currentThread().getName() + "開始執行...");
                countDownLatch.countDown();// 每次減去1
                System.out.println("子線程," + Thread.currentThread().getName() + "結束執行...");
            }
        }).start();
        new Thread(new Runnable() {

            @Override
            public void run() {
                System.out.println("子線程," + Thread.currentThread().getName() + "開始執行...");
                countDownLatch.countDown();
                System.out.println("子線程," + Thread.currentThread().getName() + "結束執行...");
            }
        }).start();

        countDownLatch.await();// 調用當前方法主線程阻塞  countDown結果為0, 阻塞變為運行狀態
        System.out.println("兩個子線程執行完畢....");
        System.out.println("繼續主線程執行..");
    }

}

 

CyclicBarrier

CyclicBarrier初始化時規定一個數目，然后計算調用了CyclicBarrier.await()進入等待的線程數。當線程數達到了這個數目時，所有進入等待狀態的線程被喚醒並繼續。 

 CyclicBarrier就象它名字的意思一樣，可看成是個障礙， 所有的線程必須到齊后才能一起通過這個障礙。 

CyclicBarrier初始時還可帶一個Runnable的參數， 此Runnable任務在CyclicBarrier的數目達到后，所有其它線程被喚醒前被執行。

class Writer extends Thread {
    private CyclicBarrier cyclicBarrier;
    public Writer(CyclicBarrier cyclicBarrier){
         this.cyclicBarrier=cyclicBarrier;
    }
    @Override
    public void run() {
        System.out.println("線程" + Thread.currentThread().getName() + ",正在寫入數據");
        try {
            Thread.sleep(3000);
        } catch (Exception e) {
            // TODO: handle exception
        }
        System.out.println("線程" + Thread.currentThread().getName() + ",寫入數據成功.....");
        
        try {
            cyclicBarrier.await();
        } catch (Exception e) {
        }
        System.out.println("所有線程執行完畢..........");
    }

}

public class Test001 {

    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier=new CyclicBarrier(5);
        for (int i = 0; i < 5; i++) {
            Writer writer = new Writer(cyclicBarrier);
            writer.start();
        }
    }

}

 

Semaphore

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

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

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

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

例：

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

public class SemaphoreTest {
    public static void main(String[] args) throws InterruptedException {


     /*   //表示最多支持多少個資源訪問，
        Semaphore semaphore=new Semaphore(3);
        //申請資源
        wc.acquire(); 
        //釋放資源
        semaphore.release();*/
        Semaphore semaphore=new Semaphore(3);
     for(int i=0;i<=10;i++){
         new Prarent(semaphore, "第"+i+"個").start();
     }
    }
}

class Prarent extends Thread{

   Semaphore wc;
   String name ;

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

    @Override
    public void run() {
        //獲取到資源后，立即減一，如5-1，代替wc.acquire();
       int a= wc.availablePermits();
       if(a>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();
        }
    }
}