Java多线程-并发容器

Java多线程-并发容器

         在Java1.5以后，经过几个并发容器类来改进同步容器类，同步容器类是经过将容器的状态串行访问，从而实现它们的线程安全的，这样作会消弱了并发性，当多个线程并发的竞争容器锁的时候，吞吐量会降低。那并发容器是为多线程并发而设计的。那么java1.5中添加了哪些并发容器？

      一、ConCurrentHashMap  来替代同步的HashMap 实现     

      二、CopyOnWriteArrayList  是List的同步实现
      三、Queue 和 BlockQueue  接口     

     四、ConCurrentLinkedQueue  一个并发优先级的队列注意： java6中加入ConCurrentSkipListMap 和 ConCurrentSkipListSet 用来做为同步的SortedMap 和SortedSet ..

2、ConCurrentHashMap     

 

咱们都知道同步容器类每当执行一个操做的时候都会持有一个锁，若是同步容器中很是大，好比遍历查找是否存某个对象，消耗时间很是长，可是这段时间不容许其余线程访问这个容器，这是一种糟糕是事情。  下载地址      ConCurrentHashMap 和HashMap 同样都是一个hash表，可是ConCurrentHashMap与HashMap彻底使用不一样的锁策略。它能够提供更好的并发性和伸缩性。在ConCurrentHashMap以前，是使用共用一个锁，进行同步每个方法。而且严格的限制只有一个线程能同时访问容器；而ConcurrentHashMap 使用了更加细粒度的锁，-分离锁（ 详情：ReentrantLock）这个锁机制容许更深层的共享访问，任何多线程能够并发的读操做访问此容器，当且仅当只用一个线程能够进行写容器操做。这样读线程和写线程均可以并发的访问容器大大提升了吞吐量，也没有怎么损失单线程的性能。可是，在应用的需求是线程独占访问枷锁的时候，ConCurrentMap是没法胜任的。

 

3、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);
    }

 

   读取不会加锁和释放锁操做。