java多線程-并發容器

         在Java1.5之后，通過幾個并發容器類來改進同步容器類，同步容器類是通過將容器的狀態串行訪問，從而實現它們的線程安全的，這樣做會消弱了并發性，當多個線程并發的競爭容器鎖的時候，吞吐量會下降。那并發容器是為多線程并發而設計的。那么java1.5中添加了哪些并發容器？

      1、ConCurrentHashMap  來替代同步的HashMap 實現     

      2、CopyOnWriteArrayList  是List的同步實現       3、Queue 和 BlockQueue  接口     

     4、ConCurrentLinkedQueue  一個并發優先級的隊列注意： java6中加入ConCurrentSkipListMap 和 ConCurrentSkipListSet 用來作為同步的SortedMap 和SortedSet ..

二、ConCurrentHashMap     

我們都知道同步容器類每當執行一個操作的時候都會持有一個鎖，如果同步容器中非常大，比如遍歷查找是否存某個對象，消耗時間非常長，但是這段時間不允許其他線程訪問這個容器，這是一種糟糕是事情。下載地址  ConCurrentHashMap 和HashMap 一樣都是一個hash表，但是ConCurrentHashMap與HashMap完全使用不同的鎖策略。它可以提供更好的并發性和伸縮性。在ConCurrentHashMap之前，是使用共用一個鎖，進行同步每一個方法。并且嚴格的限制只有一個線程能同時訪問容器；而ConcurrentHashMap 使用了更加細粒度的鎖，-分離鎖（ 詳情：ReentrantLock）這個鎖機制允許更深層的共享訪問，任何多線程可以并發的讀操作訪問此容器，當且僅當只用一個線程可以進行寫容器操作。這樣讀線程和寫線程都可以并發的訪問容器大大提高了吞吐量，也沒有怎么損失單線程的性能。但是，在應用的需求是線程獨占訪問枷鎖的時候，ConCurrentMap是無法勝任的。

三、CopyOnWriteArrayList

CopyOnWriteArrayList 是 List容器的并發容器的替代品，通常它提供了更好的并發性，避免在容器迭代時候進行加鎖和復制。下面是一段源代碼

Java代碼  

1. public E set(int index, E element) {  
2.        final ReentrantLock lock = this.lock;  
3.        lock.lock();  
4.        try {  
5.            Object[] elements = getArray();  
6.            E oldValue = get(elements, index);  
7.   
8.            if (oldValue != element) {  
9.                int len = elements.length;  
10.                Object[] newElements = Arrays.copyOf(elements, len);  
11.                newElements[index] = element;  
12.                setArray(newElements);  
13.            } else {  
14.                // Not quite a no-op; ensures volatile write semantics  
15.                setArray(elements);  
16.            }  
17.            return oldValue;  
18.        } finally {  
19.            lock.unlock();  
20.        }  
21.    }  

 public E set(int index, E element) {        final ReentrantLock lock = this.lock;        lock.lock();        try {            Object[] elements = getArray();            E oldValue = get(elements, index);            if (oldValue != element) {                int len = elements.length;                Object[] newElements = Arrays.copyOf(elements, len);                newElements[index] = element;                setArray(newElements);            } else {                // Not quite a no-op; ensures volatile write semantics                setArray(elements);            }            return oldValue;        } finally {            lock.unlock();        }    }

     在操作之前：lock.lock(); 然后  lock.unlock(); 釋放

  

Java代碼  

1. /** 
2.    * {@inheritDoc} 
3.    * 
4.    * @throws IndexOutOfBoundsException {@inheritDoc} 
5.    */  
6.   public E get(int index) {  
7.       return get(getArray(), index);  
8.   }  

  /**     * {@inheritDoc}     *     * @throws IndexOutOfBoundsException {@inheritDoc}     */    public E get(int index) {        return get(getArray(), index);    }