hashMap与hashTable区别

如果需要使 Map 线程安全，大致有这么四种方法： 

1、使用 synchronized 关键字，这也是最原始的方法。代码如下 

1. synchronized(anObject)  
2. {  
3.     value = map.get(key);  
4. }  

 

JDK1.2 提供了 Collections.synchronizedMap(originMap) 方法，同步方式其实和上面这段代码相同。

 Map Collections.synchronizedMap(Map m)

这个方法返回一个同步的Map，这个Map封装了底层的HashMap的所有方法，使得底层的HashMap即使是在多线程的环境中也是安全的。

 

 

2、使用 JDK1.5 提供的锁（java.util.concurrent.locks.Lock）。代码如下

1. lock.lock();  
2. value = map.get(key);  
3. lock.unlock();  

3、实际应用中，可能多数操作都是读操作，写操作较少。针对这种情况，可以使用 JDK1.5 提供的读写锁（java.util.concurrent.locks.ReadWriteLock）。代码如下

1. rwlock.readLock().lock();  
2. value = map.get(key);  
3. rwlock.readLock().unlock();  

 

这样两个读操作可以同时进行，理论上效率会比方法 2 高。 

 

4、使用 JDK1.5 提供的 java.util.concurrent.ConcurrentHashMap 类。该类将 Map 的存储空间分为若干块，每块拥有自己的锁，大大减少了多个线程争夺同一个锁的情况。代码如下 

1. value = map.get(key); //同步机制内置在 get 方法中  

使用转载文章中的测试代码，在我的机器上针对这四种方式进行测试，结果见附图。测试内容为 1 秒钟所有 get 方法调用次数的总和。为了比较，增加了未使用任何同步机制的情况（非安全！）。理论上，不同步应该最快。 

 

我的测试结果：

 

 

转载文章的结果：

 

测试结果和转载文章中差不多，但是synchronized 貌似没有转载中说的那么糟糕。从附图可以看出： 

1、不同步确实最快，与预期一致。 
2、四种同步方式中，ConcurrentHashMap 是最快的，接近不同步的情况。 
3、synchronized 关键字非常慢
4、使用读写锁的读锁，比普通所稍慢。

结论： 

1、如果 ConcurrentHashMap 够用，则使用 ConcurrentHashMap。 
2、如果需自己实现同步，则使用 JDK1.5 提供的锁机制，避免使用 synchronized 关键字。 

 

 

测试代码：

 

[java]  view plain copy

1. import java.util.*;  
2. import java.util.concurrent.*;  
3. import java.util.concurrent.locks.*;  
4. public class MapTest  
5. {  
6.     public static final int THREAD_COUNT = 5;  
7.     public static final int MAP_SIZE = 1000;  
8.     public static final int EXECUTION_MILLES = 1000;  
9.     public static final int[] KEYS = new int[100];   
10.       
11.     public static void main(String[] args) throws Exception  
12.     {  
13.         //初始化  
14.         Random rand = new Random();  
15.         for (int i = 0; i < KEYS.length; ++i)  
16.         {  
17.             KEYS[i] = rand.nextInt();  
18.         }  
19.                   
20.         //创建线程  
21.         long start = System.currentTimeMillis();  
22.         Thread[] threads = new Thread[THREAD_COUNT];  
23.           
24.         //生成多个相同的线程  
25.         for (int i = 0; i < THREAD_COUNT; ++i)  
26.         {  
27.             //threads[i] = new UnsafeThread();  
28.             threads[i] = new SynchronizedThread();  
29.             //threads[i] = new LockThread();  
30.             //threads[i] = new ReadLockThread();  
31.             //threads[i] = new ConcurrentThread();  
32.             threads[i].start();  
33.         }  
34.           
35.         //等待其它线程执行若干时间  
36.         Thread.sleep(EXECUTION_MILLES);  
37.         //统计 get 操作的次数  
38.         long sum = 0;         
39.         for (int i = 0; i < THREAD_COUNT; ++i)  
40.         {  
41.             //将所有的同类线程访问次数加起来  
42.             sum += threads[i].getClass().getDeclaredField("count").getLong(threads[i]);  
43.         }  
44.         long millisCost = System.currentTimeMillis() - start;  
45.         System.out.println(sum + "(" + (millisCost) + "ms)");  
46.         System.exit(0);  
47.     }  
48.       
49.     public static void fillMap(Map<Integer, Integer> map)  
50.     {  
51.         Random rand = new Random();  
52.           
53.         for (int i = 0; i < MAP_SIZE; ++i)  
54.         {  
55.             map.put(rand.nextInt(), rand.nextInt());  
56.         }  
57.     }  
58. }  
59. class UnsafeThread extends Thread  
60. {  
61.     private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();   
62.     public long count = 0;    
63.       
64.     static  
65.     {  
66.         MapTest.fillMap(map);  
67.     }  
68.       
69.     public void run()  
70.     {  
71.         for (;;)  
72.         {  
73.             int index = (int)(count % MapTest.KEYS.length);  
74.             map.get(MapTest.KEYS[index]);  
75.             ++count;  
76.         }  
77.     }  
78. }  
79. class SynchronizedThread extends Thread  
80. {  
81.     //所有同类线程共享一个map  
82.     private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();   
83.     //每个线程使用自己的计数器  
84.     public long count = 0;  
85.       
86.     //o必须是static，否则synchronized(o)每个线程只对自己的o加锁，锁没有效果  
87.     private static final Object o = new Object();  
88.       
89.     static  
90.     {  
91.         MapTest.fillMap(map);  
92.     }  
93.       
94.       
95.     public void run()  
96.     {  
97.         for (;;)  
98.         {  
99.             int index = (int)(count % MapTest.KEYS.length);  
100.               
101. //          没有锁效果的加锁方式：  
102. //          (1)private final Object o = new Object();  
103. //          synchronized(o)  
104. //          (2)synchronized(this)  
105.               
106.               
107. //          有锁效果的加锁方式：  
108. //          (1)synchronized(map)  
109. //          (2)private static final Object o = new Object();  
110. //          synchronized(o)  
111.             synchronized(SynchronizedThread.class)  
112.             {  
113.                 map.get(MapTest.KEYS[index]);  
114.             }  
115.             ++count;  
116.         }  
117.     }  
118. }  
119. class LockThread extends Thread  
120. {  
121.     private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();   
122.     private static Lock lock = new ReentrantLock();  
123.     public long count = 0;  
124.       
125.     static  
126.     {  
127.         MapTest.fillMap(map);  
128.     }  
129.       
130.     public void run()  
131.     {  
132.         for (;;)  
133.         {  
134.             int index = (int)(count % MapTest.KEYS.length);  
135.             lock.lock();  
136.             map.get(MapTest.KEYS[index]);  
137.             lock.unlock();  
138.             ++count;  
139.         }  
140.     }  
141. }  
142. class ReadLockThread extends Thread  
143. {  
144.     private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();   
145.     private static Lock lock = new ReentrantReadWriteLock().readLock();  
146.     public long count = 0;  
147.       
148.     static  
149.     {  
150.         MapTest.fillMap(map);  
151.     }  
152.       
153.     public void run()  
154.     {  
155.         for (;;)  
156.         {  
157.             int index = (int)(count % MapTest.KEYS.length);  
158.             lock.lock();  
159.             map.get(MapTest.KEYS[index]);  
160.             lock.unlock();  
161.             ++count;  
162.         }  
163.     }  
164. }  
165. class ConcurrentThread extends Thread  
166. {  
167.     private static Map<Integer, Integer> map = new ConcurrentHashMap<Integer, Integer>();     
168.     public long count = 0;  
169.       
170.     static  
171.     {  
172.         MapTest.fillMap(map);  
173.     }  
174.       
175.     public void run()  
176.     {  
177.         for (;;)  
178.         {  
179.             int index = (int)(count % MapTest.KEYS.length);  
180.             map.get(MapTest.KEYS[index]);  
181.             ++count;  
182.         }  
183.     }  
184. }  

 

 

补充：

 

（1）虽然ConcurrentHashMap是线程安全的，而且性能很高，但是

 

看看下面一段代码：

[java]  view plain copy

1. ConcurrentHashMap<String,String> map;  
2.     String getString(String name) {  
3.         String x = map.get(name);  
4.         if (x == null) {  
5.             x = new String();  
6.             map.put(name, x);  
7.         }  
8.         return x;  
9.     }  

 

 

 

 

如果你只调用get（），或只调用put（）时，ConcurrentHashMap是线程安全的。

但是，在你调用完get后，调用put之前，

如果有另外一个线程调用了map.put(name, x)，

你再去执行map.put(name,x)，

就很可能把前面的操作结果覆盖掉了。

所以，即使在线程安全的情况下，

你还是有可能违反原子操作的规则。

 

避免方法：将get和put放到一个锁下面

 

 

[java]  view plain copy

1. Map map = Collections.synchronizedMap(new HashMap());  
2. String getString(String name) {   
3.     synchronized(map){//可保证该同步块内的所有代码对map是一个原子操作。  
4.         String x = map.get(name);   
5.         if (x == null) {   
6.             x = new String();   
7.             map.put(name, x);   
8.         }   
9.         return x;  
10.     }   
11. }   

 

 

（2）在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键，而应该用containsKey()方法来判断。