5.1 同步容器类

柔情只为你懂 2022-05-23 04:28 176阅读 0赞

同步容器类包括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();
        }
    }

它的运行结果不确定：

![70][]

![70 1][]

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

![20180601230723560][]

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

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异常。

[70]: /images/20220523/3816ae4a16b9465e86d2bb634de0c141.png
[70 1]: /images/20220523/90a9b16dfd514b01b5c6bf581c32028a.png
[20180601230723560]: /images/20220523/066a75cfadb540d482ef4aaca70d47a7.png