【Java併發編程二】Java併發包

1.Java容器

1.1.同步容器

Vector

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

Vector與ArrayList同樣，也是經過數組實現的，不一樣的是它支持線程的同步，即某一時刻只有一個線程可以寫Vector，避免多線程同時寫而引發的不一致性，但實現同步須要很高的花費，所以，訪問它比訪問ArrayList慢

注意: Vector線程安全，數組的擴容默認2倍，能夠自定義。而ArrayList數組的擴容是1.5倍

Vector源碼類

Add方法源碼類

 

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

 

Arraylist源碼

Add方法源碼

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

HashTable

 

HashMap是一個接口 是map接口的子接口，是將鍵映射到值的對象，其中鍵和值都是對象，而且不能包含重複鍵，但能夠包含重複值。HashMap容許null key和null value，而hashtable不容許。

HashTable是線程安全的一個Collection。

HashMap是Hashtable的輕量級實現（非線程安全的實現），他們都完成了Map接口，主要區別在於HashMap容許空（null）鍵值（key）,因爲非線程安全，效率上可能高於Hashtable。

HashMap容許將null做爲一個entry的key或者value，而Hashtable不容許。
HashMap把Hashtable的contains方法去掉了，改爲containsvalue和containsKey。

注意: HashTable 是線程安全的，HashMap是線程不安全的

 

HashTable源碼類

put方法源碼類

 1  public synchronized V put(K key, V value) {
 2         // Make sure the value is not null
 3         if (value == null) {
 4             throw new NullPointerException();
 5         }
 6 
 7         // Makes sure the key is not already in the hashtable.
 8         Entry<?,?> tab[] = table;
 9         int hash = key.hashCode();
10         int index = (hash & 0x7FFFFFFF) % tab.length;
11         @SuppressWarnings("unchecked")
12         Entry<K,V> entry = (Entry<K,V>)tab[index];
13         for(; entry != null ; entry = entry.next) {
14             if ((entry.hash == hash) && entry.key.equals(key)) {
15                 V old = entry.value;
16                 entry.value = value;
17                 return old;
18             }
19         }
20 
21         addEntry(hash, key, value, index);
22         return null;
23     }

 

HashMap源碼類

put方法源碼類

1     public V put(K key, V value) {
2 
3         return putVal(hash(key), key, value, false, true);
4 
5     }

 

Collections.synchronized*()

Collections類下的synchronized* 方法能夠將不安全的集合變成線程安全的集合

例如：

1 Collections.synchronizedMap(new HashMap<>(10));
2 Collections.synchronizedList(new ArrayList<>());
3 Collections.synchronizedSet(new HashSet<>());

1.2.併發容器

ConcurrentHashMap

ConcurrentHashMap與HashMap同樣是一個哈希表，可是它使用徹底不一樣的鎖策略，能夠提供更好的併發性和可伸縮性。在ConcurrentHashMap之前，程序使用一個公共鎖同步一個方法，並嚴格地控制只能在一個線程中能夠同時訪問容器，而ConcurrentHashMap使用一個更爲細化的鎖機制，名叫分離鎖。這個機制容許任意數量的讀線程能夠併發訪問Map，讀者和寫者也能夠併發訪問Map，而且有限數量的寫進程還能夠併發修改Map，結果是爲併發訪問帶來更高的吞吐量，同時幾乎沒有損失單個線程訪問的性能。

　　ConcurrentHashMap是由Segment數組結構和HashEntry數組結構組成。Segment是一種可重入鎖ReentrantLock，在ConcurrentHshMap裏扮演鎖的角色，HashEntry則用於存儲鍵值對數據。一個ConcurrentHashMap裏包含一個Segment數組，Segment的結構和HashMap相似，是一種數組和鏈表結構，一個Segment裏包含一個HashEntry數組，每個HashEntry是一個鏈表結構的元素，每一個Segment守護着HashEntry數組裏的元素，當對HashEntry數組的數據進行修改時，必須首先得到它對應的Segment的鎖。

 

注意:ConcurrentHashMap是線程安全的，因爲代碼中大多數全局變量使用volatile關鍵字聲明，因此性能較好

 

ConcurrentSkipListMap

ConcurrentSkipListMap是在ConcurrentHashMap的基礎上，增長了排序功能

 

2.Java併發隊列

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。（在多線程領域：所謂阻塞，在某些狀況下會掛起線程（即阻塞），一旦條件知足，被掛起的線程又會自動被喚醒）

 

 

ArrayBlockingQueue

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

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

 

LinkedBlockingQueue

LinkedBlockingQueue阻塞隊列大小的配置是可選的，若是咱們初始化時指定一個大小，它就是有邊界的，若是不指定，它就是無邊界的。說是無邊界，實際上是採用了默認大小爲Integer.MAX_VALUE的容量 。它的內部實現是一個鏈表。

和ArrayBlockingQueue同樣，LinkedBlockingQueue 也是以先進先出的方式存儲數據，最新插入的對象是尾部，最新移出的對象是頭部。

 

PriorityBlockingQueue

PriorityBlockingQueue是一個沒有邊界的隊列，它的排序規則和 java.util.PriorityQueue同樣。須要注意，PriorityBlockingQueue中容許插入null對象。

全部插入PriorityBlockingQueue的對象必須實現 java.lang.Comparable接口，隊列優先級的排序規則就是按照咱們對這個接口的實現來定義的。

另外，咱們能夠從PriorityBlockingQueue得到一個迭代器Iterator，但這個迭代器並不保證按照優先級順序進行迭代。

SynchronousQueue

SynchronousQueue隊列內部僅容許容納一個元素。當一個線程插入一個元素後會被阻塞，除非這個元素被另外一個線程消費。