HashMap和ConcurrentHashMap的并发性能测试

原文：http://www.java2000.net/p12427

先看看代码吧，模拟1000个并发，每个测试1000次操作，循环测试10轮。分别测试Put和Get操作

1. import java.util.Collections;
2. import java.util.HashMap;
3. import java.util.Hashtable;
4. import java.util.Map;
5. import java.util.concurrent.ConcurrentHashMap;
7. /**
8.  * 测试HashMap和ConcurrentHashMap的并发性能差别。
9.  * 
10.  * @author 老紫竹 JAVA世纪网(java2000.net)
11.  * 
12.  */
13. public class T {
14.   static final int threads = 1000;
15.   static final int NUMBER = 1000;
17.   public static void main(String[] args) throws Exception {
18.     Map<String, Integer> hashmapSync = Collections
19.         .synchronizedMap(new HashMap<String, Integer>());
20.     Map<String, Integer> concurrentHashMap = new ConcurrentHashMap<String, Integer>();
21.     Map<String, Integer> hashtable = new Hashtable<String, Integer>();
23.     long totalA = 0;
24.     long totalB = 0;
25.     long totalC = 0;
26.     for (int i = 0; i <= 10; i++) {
27.       totalA += testPut(hashmapSync);
28.       totalB += testPut(concurrentHashMap);
29.       totalC += testPut(hashtable);
30.     }
31.     System.out.println("Put time HashMapSync=" + totalA + "ms.");
32.     System.out.println("Put time ConcurrentHashMap=" + totalB + "ms.");
33.     System.out.println("Put time Hashtable=" + totalC + "ms.");
35.     totalA = 0;
36.     totalB = 0;
37.     totalC = 0;
38.     for (int i = 0; i <= 10; i++) {
39.       totalA += testGet(hashmapSync);
40.       totalB += testGet(concurrentHashMap);
41.       totalC += testGet(hashtable);
42.     }
43.     System.out.println("Get time HashMapSync=" + totalA + "ms.");
44.     System.out.println("Get time ConcurrentHashMap=" + totalB + "ms.");
45.     System.out.println("Get time Hashtable=" + totalC + "ms.");
46.   }
48.   public static long testPut(Map<String, Integer> map) throws Exception {
49.     long start = System.currentTimeMillis();
50.     for (int i = 0; i < threads; i++) {
51.       new MapPutThread(map).start();
52.     }
53.     while (MapPutThread.counter > 0) {
54.       Thread.sleep(1);
55.     }
56.     return System.currentTimeMillis() - start;
57.   }
59.   public static long testGet(Map<String, Integer> map) throws Exception {
60.     long start = System.currentTimeMillis();
61.     for (int i = 0; i < threads; i++) {
62.       new MapPutThread(map).start();
63.     }
64.     while (MapPutThread.counter > 0) {
65.       Thread.sleep(1);
66.     }
67.     return System.currentTimeMillis() - start;
68.   }
69. }
71. class MapPutThread extends Thread {
72.   static int counter = 0;
73.   static Object lock = new Object();
74.   private Map<String, Integer> map;
75.   private String key = this.getId() + "";
77.   MapPutThread(Map<String, Integer> map) {
78.     synchronized (lock) {
79.       counter++;
80.     }
81.     this.map = map;
82.   }
84.   public void run() {
86.     for (int i = 1; i <= T.NUMBER; i++) {
87.       map.put(key, i);
88.     }
89.     synchronized (lock) {
90.       counter--;
91.     }
92.   }
93. }
95. class MapGetThread extends Thread {
96.   static int counter = 0;
97.   static Object lock = new Object();
98.   private Map<String, Integer> map;
99.   private String key = this.getId() + "";
101.   MapGetThread(Map<String, Integer> map) {
102.     synchronized (lock) {
103.       counter++;
104.     }
105.     this.map = map;
106.   }
108.   public void run() {
110.     for (int i = 1; i <= T.NUMBER; i++) {
111.       map.get(key);
112.     }
113.     synchronized (lock) {
114.       counter--;
115.     }
116.   }
117. }

运行结果：
Put time HashMapSync=3966ms.
Put time ConcurrentHashMap=1892ms.
Put time Hashtable=3892ms.
Get time HashMapSync=3812ms.
Get time ConcurrentHashMap=1828ms.
Get time Hashtable=3985ms.


结论：
ConcurrentHashMap的性能比同步的HashMap快一倍左右
同步的HashMap和Hashtable的性能相当