转：java多线程--同步容器

• java同步容器

　　在Java的集合容器框架中，主要有四大类别：List、Set、Queue、Map。List、Set、Queue接口分别继承了Collection接口，Map本身是一个接口。注意Collection和Map是一个顶层接口，而List、Set、Queue则继承了Collection接口，分别代表数组、集合和队列这三大类容器。像ArrayList、LinkedList、HashMap这些容器都是非线程安全的。因此，在编写程序时，必须要求程序员手动地在任何访问到这些容器的地方进行同步处理，这样导致在使用这些容器的时候非常地不方便。

• java中的同步容器

　　1）Vector、Stack、HashTable　　

　　Vector实现了List接口，Vector实际上就是一个数组，和ArrayList类似，但是Vector中的方法都是synchronized方法，即进行了同步措施。

　　Stack也是一个同步容器，它的方法也用synchronized进行了同步，它实际上是继承于Vector类。

　　HashTable实现了Map接口，它和HashMap很相似，但是HashTable进行了同步处理，而HashMap没有。

　　2）Collections类中提供的静态工厂方法创建的类：

　　Collections类是一个工具提供类，注意，它和Collection不同，Collection是一个顶层的接口。在Collections类中提供了大量的方法，比如对集合或者容器进行排序、查找等操作。最重要的是，在它里面提供了几个静态工厂方法来创建同步容器类。

• 同步容器缺陷

　　从同步容器的具体实现源码可知，同步容器中的方法采用了synchronized进行了同步，那么很显然，这必然会影响到执行性能，另外，同步容器不一定是真正地完全线程安全的，还需要添加额外的同步措施。

例如：

 public class Test {
     static Vector<Integer> vector = new Vector<Integer>();
     public static void main(String[] args) throws InterruptedException {
         while(true) {
             for(int i=0;i<10;i++)
                 vector.add(i);
             Thread thread1 = new Thread(){
                 public void run() {
                     for(int i=0;i<vector.size();i++)
                         vector.remove(i);
                 };
             };
             Thread thread2 = new Thread(){
                 public void run() {
                     for(int i=0;i<vector.size();i++)
                         vector.get(i);
                 };
             };
             thread1.start();
             thread2.start();
             while(Thread.activeCount()>10)   {

             }
         }
     }
 }

 public class Test {
     static Vector<Integer> vector = new Vector<Integer>();
     public static void main(String[] args) throws InterruptedException {
         while(true) {
             for(int i=0;i<10;i++)
                 vector.add(i);
             Thread thread1 = new Thread(){
                 public void run() {
                     synchronized (Test.class) {   //进行额外的同步
                         for(int i=0;i<vector.size();i++)
                             vector.remove(i);
                     }
                 };
             };
             Thread thread2 = new Thread(){
                 public void run() {
                     synchronized (Test.class) {
                         for(int i=0;i<vector.size();i++)
                             vector.get(i);
                     }
                 };
             };
             thread1.start();
             thread2.start();
             while(Thread.activeCount()>10)   {

             }
         }
     }
 }

• ConcurrentModificationException异常

　　在对容器并发地进行迭代修改时，会报ConcurrentModificationException异常。

 public class Test {
     public static void main(String[] args)  {
         ArrayList<Integer> list = new ArrayList<Integer>();
         list.add(2);
         Iterator<Integer> iterator = list.iterator();
         while(iterator.hasNext()){
             Integer integer = iterator.next();
             if(integer==2)
                 list.remove(integer);
         }
     }
 }

　　这样会报ConcurrentModificationException异常，我们定位到源码查看。

 private class Itr implements Iterator<E> {
         int cursor;       // index of next element to return
         int lastRet = -1; // index of last element returned; -1 if no such
         int expectedModCount = modCount;

         public boolean hasNext() {
             return cursor != size;
         }

         @SuppressWarnings("unchecked")
         public E next() {
             checkForComodification();
             int i = cursor;
             if (i >= size)
                 throw new NoSuchElementException();
             Object[] elementData = ArrayList.this.elementData;
             if (i >= elementData.length)
                 throw new ConcurrentModificationException();
             cursor = i + 1;
             return (E) elementData[lastRet = i];
         }

         public void remove() {
             if (lastRet < 0)
                 throw new IllegalStateException();
             checkForComodification();

             try {
                 ArrayList.this.remove(lastRet);
                 cursor = lastRet;
                 lastRet = -1;
                 expectedModCount = modCount;
             } catch (IndexOutOfBoundsException ex) {
                 throw new ConcurrentModificationException();
             }
         }

         final void checkForComodification() {
             if (modCount != expectedModCount)
                 throw new ConcurrentModificationException();
         }
  }

　　首先我们看一下它的几个成员变量：

　　cursor：表示下一个要访问的元素的索引，从next()方法的具体实现就可看出

　　lastRet：表示上一个访问的元素的索引

　　expectedModCount：表示对ArrayList修改次数的期望值，它的初始值为modCount。

　　modCount是AbstractList类中的一个成员变量，该值表示对List的修改次数，查看ArrayList的add()和remove()方法就可以发现，每次调用add()方法或者remove()方法等就会对modCount进行加1操作。

　　因为modCount的修改，而导致expectedModCount和modCount不相等，即checkForComodification（）抛异常导致。

　　解决方法：

　　1：单线程环境下：iterator.remove();

　　2：多线程环境下：

　　　　1）在使用iterator迭代的时候使用synchronized或者Lock进行同步；

　　　　2）使用并发容器CopyOnWriteArrayList代替ArrayList和Vector。

• java5新增的并发类

　　大家都知道HashMap是非线程安全的，Hashtable是线程安全的，但是由于Hashtable是采用synchronized进行同步，相当于所有线程进行读写时都去竞争一把锁，导致效率非常低下。ConcurrentHashMap可以做到读取数据不加锁，并且其内部的结构可以让其在进行写操作的时候能够将锁的粒度保持地尽量地小，不用对整个ConcurrentHashMap加锁。　　

　　CopyOnWrite容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

　　CopyOnWrite容器有很多优点，但是同时也存在两个问题，即内存占用问题和数据一致性问题：CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。

　　参考博客：

　　http://home.cnblogs.com/u/dolphin0520/