5.1 同步容器类

    同步容器类包括Vector和HashTable，二者都是早起JDK的一部分，此外还包括JDK1.2中添加的一些功能相似的类，这些同步的封装器类是由Collection.synchronizedXxx等工厂方法创建的。这些类实现线程安全的方式是：将它们的状态封装起来，并对每个共有方法都进行同步，使得每次只用一个线程能访问容器的状态。

5.1.1 同步容器类的问题

    同步容器类都是线程安全的，但在某些情况下可能需要额外的客户端加锁来保护复合操作。容器上常见的复合操作包括：迭代、跳转以及条件运算，例如“若没有则添加”。在同步容器类中，这些复合操作在没有客户端加锁的情况下仍然是线程安全的，但当其他线程并发地修改容器时，它们可能会表现出意料之外的行为。

    如下例子：    

package JavaDay6_01;

import java.util.Vector;

/**
 * @author myvina@qq.com
 * @date 18-6-1  下午10:39
 */

public class Demo1 {
    public Vector<String> vector = new Vector<>();

    public Vector<String> getVector() {
        return vector;
    }

    public Object getLast() {
        int lastIndex = vector.size() - 1;
        return vector.get(lastIndex);
    }

    public void deleteLast() {
        int lastIndex = vector.size() - 1;
        vector.remove(lastIndex);
    }

    private class getVector extends Thread {
        private final Demo1 demo1;

        public getVector(Demo1 demo1) {
            this.demo1 = demo1;
        }

        @Override
        public void run() {
            for(int i = 0; i < 10; i++) {
                System.out.println(demo1.getLast());
            }
        }
    }

    private class deleteVector extends Thread {
        private final Demo1 demo1;

        public deleteVector(Demo1 demo1) {
            this.demo1 = demo1;
        }

        @Override
        public void run() {
            for(int i = 0; i < 10; i++) {
                demo1.deleteLast();
            }
        }
    }

    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        Vector<String> vector= demo1.getVector();

        for(int i = 0; i < 10; i ++) {
            vector.add("str: " + i);
        }

        demo1.new getVector(demo1).start();
        demo1.new deleteVector(demo1).start();
    }
}

    它的运行结果不确定：

    

 错误与否全看运气，因为会出现如图所示的错误：

   可以做如下修改即可保证不抛出异常：    

public Object getLast() {
        synchronized (vector) {
            int lastIndex = vector.size() - 1;
            return vector.get(lastIndex);
        }
    }

    public void deleteLast() {
        synchronized (vector) {
            int lastIndex = vector.size() - 1;
            vector.remove(lastIndex);
        }
    }

5.1.2 迭代器和ConcurrentModificationException

    对容器类进行迭代的标准方式是使用Iterator。同步容器类在迭代过程中被修改时会抛出一个ConcurrentModificationException异常。要避免抛出异常，就必须在迭代过程中持有容器的锁。如下：    

List<String>  list = Collections.synchronizedList(new ArrayList<String>());
        
   for(String item : list) {
       doSomething(item);
   }

    如果容器规模很大，线程将长时间等待，也可能会产生死锁。

    如果不希望在迭代期间对容器加锁，那么一种替代方法就是“克隆”容器，并在副本上进行迭代。但克隆容器将有显著的性能开销。

5.1.3 隐藏迭代器

    有时候虽然没有显式进行迭代，但程序有时候也会隐式地调用迭代器，如对list进行System.Out.println(list)时，会隐式地进行迭代。容器类的很多操作都会隐式地调用迭代器。要时刻注意。所有隐式地迭代操作都可能抛出ConcurrentModificationException异常。