Java 集合 构建线程安全

Java 集合 线程安全

1.转载自：http://www.gzu521.com/campus/article/program/200704/145222.htm

Java代码

1. vector是一种老的动态数组，是线程同步的，效率很低，一般不赞成使用。   
2.   
3.   
4. 五、线程安全类     
5. 在集合框架中，有些类是线程安全的，这些都是jdk1.1中的出现的。在jdk1.2之后，就出现许许多多非线程安全的类。     
6. 下面是这些线程安全的同步的类：     
7.   
8. <STRONG>vector</STRONG>   
9.   
10.   
11.   
12.   
13.   
14. ：就比arraylist多了个同步化机制（线程安全）。     
15. statck：堆栈类，先进后出。     
16.   
17. <STRONG>hashtable</STRONG>   
18.   
19.   
20.   
21.   
22.   
23. ：就比hashmap多了个线程安全。     
24. enumeration：枚举，相当于迭代器。     
25.   
26. 除了这些之外，其他的都是非线程安全的类和接口。     
27.   
28. 线程安全的类其方法是同步的，每次只能一个访问。是重量级对象，效率较低。   
29. 对于非线程安全的类和接口，在多线程中需要程序员自己处理线程安全问题。  

vector是一种老的动态数组，是线程同步的，效率很低，一般不赞成使用。五、线程安全类 在集合框架中，有些类是线程安全的，这些都是jdk1.1中的出现的。在jdk1.2之后，就出现许许多多非线程安全的类。  下面是这些线程安全的同步的类：  vector：就比arraylist多了个同步化机制（线程安全）。  statck：堆栈类，先进后出。  hashtable：就比hashmap多了个线程安全。  enumeration：枚举，相当于迭代器。  除了这些之外，其他的都是非线程安全的类和接口。  线程安全的类其方法是同步的，每次只能一个访问。是重量级对象，效率较低。对于非线程安全的类和接口，在多线程中需要程序员自己处理线程安全问题。

分析：vector，因为效率较低，现在已经不太建议使用。

在web应用中，特别是前台页面，往往效率（页面响应速度）是优先考虑的。

（20090414追加）

2.转载自：http://topic.csdn.net/u/20090328/23/9f10c0de-1722-43d0-8c96-8ab1923270e7.html

Java代码

1. hashtable跟hashmap的区别   
2. hashtable是线程安全的,即hashtable的方法都提供了同步机制!   
3.   
4.   
5. hashmap不是线程安全的,即不提供同步机制   
6.   
7.   
8. hashtable不允许插入空值,hashmap允许! 

hashtable跟hashmap的区别hashtable是线程安全的,即hashtable的方法都提供了同步机制!hashmap不是线程安全的,即不提供同步机制hashtable不允许插入空值,hashmap允许!

3.转载自：http://mahuangyihao.javaeye.com/blog/181156

Java代码

1. 线程安全的集合包含2个问题   
2. 1.多线程并发修改一 个 集合 怎么办？   
3. 2.如果迭代的过程中 集合 被修改了怎么办？   
4.     a.一个线程在迭代，另一个线程在修改   
5.     b.在同一个线程内用同一个迭代器对象进行迭代、修改、迭代、修改. . .   
6.   
7.     
8.   
9. 共有有3种解决方案   
10. 1.用老的Vector/Hashtable类，上面2个问题都不用担心。   
11. Vector/Hashtable所提供的所有方法都是 synchronized的。如果 迭代的过程中数据结构被修改了，迭代器可以反映最新的修改，也不会抛异常。但这种方法效率低下，不建议使用。   
12.   
13.     
14.   
15. 2.使用ArrayList/HashMap和同步包装器   
16.   
17. 可用 同步包装器使容器变成线程安全的   
18. Java代码   
19.   
20.    1. List synchArrayList = Collections.synchronizedList(new ArrayList());<br>     
21.    2. Map synchHashMap = Collections.synchronizedMap(new HashMap())<br>     
22.   
23. List synchArrayList = Collections.synchronizedList(new ArrayList());   
24.   
25. Map synchHashMap = Collections.synchronizedMap(new HashMap())   
26.   
27. 如果要迭代，需要这样   
28. Java代码   
29.   
30.    1. synchronized (synchHashMap)<br>     
31.    2. {<br>     
32.    3.    Iterator iter = synchHashMap.keySet().iterator();<br>     
33.    4.    while (iter.hasNext()) . . .;<br>     
34.    5. }<br>     
35.   
36. synchronized (synchHashMap)   
37.   
38. {   
39.   
40.    Iterator iter = synchHashMap.keySet().iterator();   
41.   
42.    while (iter.hasNext()) . . .;   
43.   
44. }   
45.   
46.   
47.     
48.   
49. 注意上面的代码每次进入同步块都生成了一个新的迭代器。如果你还用老的迭代器，2b的情况就可能发生，你会收到一个ConcurrentModificationException。   
50.   
51.     
52.   
53. 3.用java5.0新加入的ConcurrentLinkedQueue、ConcurrentHashMap、CopyOnWriteArrayList 和 CopyOnWriteArraySet   
54. 对这些集合进行并发修改是安全的。   
55. 针对2b的问题，迭代器既不抛异常，也不会反映新的修改。就是说你迭代的是生成迭代器时的容器，不是最新的容器。 

线程安全的集合包含2个问题1.多线程并发修改一 个 集合 怎么办？2.如果迭代的过程中 集合 被修改了怎么办？ a.一个线程在迭代，另一个线程在修改 b.在同一个线程内用同一个迭代器对象进行迭代、修改、迭代、修改. . . 共有有3种解决方案1.用老的Vector/Hashtable类，上面2个问题都不用担心。Vector/Hashtable所提供的所有方法都是 synchronized的。如果 迭代的过程中数据结构被修改了，迭代器可以反映最新的修改，也不会抛异常。但这种方法效率低下，不建议使用。 2.使用ArrayList/HashMap和同步包装器可用 同步包装器使容器变成线程安全的Java代码 1. List synchArrayList = Collections.synchronizedList(new ArrayList());<br> 2. Map synchHashMap = Collections.synchronizedMap(new HashMap())<br> List synchArrayList = Collections.synchronizedList(new ArrayList());Map synchHashMap = Collections.synchronizedMap(new HashMap())如果要迭代，需要这样Java代码 1. synchronized (synchHashMap)<br> 2. {<br> 3. Iterator iter = synchHashMap.keySet().iterator();<br> 4. while (iter.hasNext()) . . .;<br> 5. }<br> synchronized (synchHashMap){ Iterator iter = synchHashMap.keySet().iterator(); while (iter.hasNext()) . . .;} 注意上面的代码每次进入同步块都生成了一个新的迭代器。如果你还用老的迭代器，2b的情况就可能发生，你会收到一个ConcurrentModificationException。 3.用java5.0新加入的ConcurrentLinkedQueue、ConcurrentHashMap、CopyOnWriteArrayList 和 CopyOnWriteArraySet对这些集合进行并发修改是安全的。针对2b的问题，迭代器既不抛异常，也不会反映新的修改。就是说你迭代的是生成迭代器时的容器，不是最新的容器。

分析（20090414追加）：

方案1：Vector和HashTable都是线程安全的。

方案2：返回的都是经过封装（线程安全的）的list和map。

->将指定的list和map传进去，传出来的是经过线程安全处理的list和map。（20090507追加）

static <T> List <T>	synchronizedList (List <T> list)           Returns a synchronized (thread-safe) list backed by the specified list.
static <K,V> Map <K,V>	synchronizedMap (Map <K,V> m)           Returns a synchronized (thread-safe) map backed by the specified map.

方案3：这几个类都是位于java.util.concurrent 包中。（concurrent：并发的, 协作的, 一致的。也就是同步的意思。 ）

①java.util.concurrent 包中的Class ConcurrentLinkedQueue<E>：An unbounded thread-safequeue based on linked nodes.（无界线程安全队列基于联系节点。）

②java.util.concurrent 包中的Class ConcurrentHashMap<K,V>：A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updates.（哈希表的全面支持并发检索和可调预计并发更新。）

③java.util.concurrent 包中的Class CopyOnWriteArrayList<E>：A thread-safe variant of

ArrayList

in which all mutative operations (add, set, and so on) are implemented by making a fresh copy of the underlying array.（线程安全的变体的ArrayList中，所有变化的行动（购买，设置，等等）的实施作出了新的副本的基本元素。）

④java.util.concurrent 包中的Class CopyOnWriteArraySet<E>：A

Set

that uses

CopyOnWriteArrayList

for all of its operations.（一组使用CopyOnWriteArrayList其所有的业务。）

 

以上内容来自网络：http://ronaldo97.blog.163.com/blog/static/12209910520097762835651/