第七章：同步类容器，vector 线程安全与hashmap线程不安全等的举例

转自：https://blog.csdn.net/u012453843/article/details/73744277

  同步类容器，常见的有Vectorr和HashTable，也就是我们常说的线程安全的两个集合容器，这些容器的同步功能其实都是由JDK的Collections.synchronized***等工厂方法去创建的。其底层的机制无非就是用传的synchronized关键字对每个共用的方法都进行同步，使得每次只能有一个线程访问容器的状态。这很明显不满足我们今天互联网时代高并发的需求，在保证线程安全的同时，也必须要有足够好的性能。

        同步类容器虽然是线程安全的，但是在某些场景下可能需要加锁来保护复合操作。复合类操作如：迭代（反复访问元素，遍历完容器中所有的元素）、跳转（根据指定的顺序找到当前元素的下一个元素）、以及条件运算。这些复合操作在多线程并发地修改容器时，可能会表现出意外的行为，最经典的便是ConcurrentModificationException，原因是当容器迭代的过程中，被并发的修改了内容，这是由于早期迭代器设计的时候并没有考虑并发修改的问题。

        上面都是些干巴巴的理论，下面我们来看一个例子，这个例子就是同步容器出现异常的情况。我们在迭代容器中的元素的时候是不能增加或减少元素的，否则就会报ConcurrentModificationException异常。这跟我们遍历ArrayList的时候删除或增加元素报异常是一样的。

package com.xiaoyexinxin.ThreadLearn;

import java.util.Iterator;  
import java.util.Vector;  
  
/**  
 * 同步类容器  
 *  
 */  
public class SynContainer {  
    //初始化火车票池并添加火车票：为避免线程安全问题，可采用Vector替代ArrayList，HashTable替代HashMap  
    public static void main(String[] args){  
        final Vector<String> tickets = new Vector<>();  
        //向tickets中添加票  
        for(int i=0;i<=100;i++){  
            tickets.add("火车票"+i);  
        }  
        //遍历tickets，并在遍历的过程当中删除一个元素  
        for (Iterator iterator = tickets.iterator(); iterator.hasNext();) {  
            String element = (String) iterator.next();  
            tickets.remove(10);//删除掉索引号为10的元素  
        }  
    }  
}

结果：

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.Vector$Itr.checkForComodification(Unknown Source)
	at java.util.Vector$Itr.next(Unknown Source)
	at com.xiaoyexinxin.ThreadLearn.SynContainer.main(SynContainer.java:20)

之所以说Vector是线程安全的，我们看一下add方法便知道了，如下图所示，可以看到，上来便在add方法上加上了synchronized锁，同一时间只能有一个线程进行写操作，当然线程安全了，但是随之而来的便是效率太过低下。

另外遍历过程中不能使用remove删除元素；这种方式的问题在于，删除某个元素后，list的大小发生了变化，而你的索引也在变化，所以会导致你在遍历的时候漏掉某些元素。比如当你删除第1个元素后，继续根据索引访问第2个元素时，因为删除的关系后面的元素都往前移动了一位，所以实际访问的是第3个元素。因此，这种方式可以用在删除特定的一个元素时使用，但不适合循环删除多个元素时使用.

同理remove也是有synchronized同步锁的。

   我们知道，HashMap不是线程安全的，那么我们怎么验证HashMap不是线程安全的呢？我们举个例子，如下图所示。

package com.xiaoyexinxin.ThreadLearn;

import java.util.Collections;  
import java.util.HashMap;  
import java.util.Map;  
  
public class SynContainer2 {  
     
    public static void main(String[] args){  
       //Map<String,String> map = Collections.synchronizedMap(new HashMap<String,String>());  
        final Map<String,String> map = new HashMap<String,String>();  
       Thread t1 = new Thread(new Runnable() {  
          
            public void run() {  
                for(int i=0;i<25;i++){  
                    map.put(String.valueOf(i), String.valueOf(i));  
                }  
            }  
        },"t1");  
         
        Thread t2 = new Thread(new Runnable() {  
              
            @Override  
            public void run() {  
                for(int j=25;j<50;j++){  
                    map.put(String.valueOf(j), String.valueOf(j));  
                }  
            }  
        },"t2");  
        t1.start();  
        t2.start();  
        try {  
            Thread.sleep(1000);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        } 
        System.out.println("@@@");
        for(int k=0;k<50;k++){  
//            if(!String.valueOf(k).equals(map.get(String.valueOf(k)))){  
                System.out.println(String.valueOf(k)+":"+map.get(String.valueOf(k)));  
//            }  
        }  
    }  

}

结果：

@@@
0:0
1:1
2:2
3:3
4:4
5:5
6:6
7:7
8:8
9:9
10:null
11:null
12:12
13:null
14:null
15:15
16:16
17:17
18:18
19:19
20:20
21:21
22:22
23:23
24:24
25:null
26:26
27:27
28:28
29:29
30:30
31:31
32:32
33:33
34:34
35:35
36:36
37:37
38:38
39:39
40:40
41:41
42:42
43:43
44:44
45:45
46:46
47:47
48:48
49:49

运行上面的方法，有时会看到如下图所示的结果，我们明明向map中添加的都是整数转成的字符串，现在却出现了这种数据，说明HashMap不是线程安全的。

 我们再把HashMap经过Collections.synchronizedMap进行处理（把注释掉的那行代码放开，如下图所示）。

再多执行几次main方法，发现没有任何异常数据输出，这说明经过Collections.synchronizedMap(new HashMap<String,String>());这样处理的HashMap已经变成线程安全的了。不过，由于它加了锁，因此并发效率自然而然就低了。

package com.xiaoyexinxin.ThreadLearn;

import java.util.Collections;  
import java.util.HashMap;  
import java.util.Map;  
  
public class SynContainer2 {  
     
    public static void main(String[] args){  
       final Map<String,String> map = Collections.synchronizedMap(new HashMap<String,String>());  
//        final Map<String,String> map = new HashMap<String,String>();  
       Thread t1 = new Thread(new Runnable() {  
          
            public void run() {  
                for(int i=0;i<25;i++){  
                    map.put(String.valueOf(i), String.valueOf(i));  
                }  
            }  
        },"t1");  
         
        Thread t2 = new Thread(new Runnable() {  
              
            @Override  
            public void run() {  
                for(int j=25;j<50;j++){  
                    map.put(String.valueOf(j), String.valueOf(j));  
                }  
            }  
        },"t2");  
        t1.start();  
        t2.start();  
        try {  
            Thread.sleep(1000);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        } 
        System.out.println("@@@");
        for(int k=0;k<50;k++){  
//            if(!String.valueOf(k).equals(map.get(String.valueOf(k)))){  
                System.out.println(String.valueOf(k)+":"+map.get(String.valueOf(k)));  
//            }  
        }  
    }  

}