轉自 http://www.iteye.com/topic/164644
如果需要使 Map 線程安全，大緻有這麼四種方法：
1、使用 synchronized 關鍵字，這也是最原始的方法。代碼如下
- synchronized(anObject)
- {
- value = map.get(key);
- }
JDK1.2 提供了 Collections.synchronizedMap(originMap) 方法，同步方式其實和上面這段代碼相同。
Map Collections.synchronizedMap(Map m)
這個方法傳回一個同步的Map，這個Map封裝了底層的HashMap的所有方法，使得底層的HashMap即使是在多線程的環境中也是安全的。
2、使用 JDK1.5 提供的鎖（java.util.concurrent.locks.Lock）。代碼如下
- lock.lock();
- value = map.get(key);
- lock.unlock();
3、實際應用中，可能多數操作都是讀操作，寫操作較少。針對這種情況，可以使用 JDK1.5 提供的讀寫鎖（java.util.concurrent.locks.ReadWriteLock）。代碼如下
- rwlock.readLock().lock();
- value = map.get(key);
- rwlock.readLock().unlock();
這樣兩個讀操作可以同時進行，理論上效率會比方法 2 高。
4、使用 JDK1.5 提供的 java.util.concurrent.ConcurrentHashMap 類。該類将 Map 的存儲空間分為若幹塊，每塊擁有自己的鎖，大大減少了多個線程争奪同一個鎖的情況。代碼如下
- value = map.get(key); //同步機制内置在 get 方法中
使用轉載文章中的測試代碼，在我的機器上針對這四種方式進行測試，結果見附圖。測試内容為 1 秒鐘所有 get 方法調用次數的總和。為了比較，增加了未使用任何同步機制的情況（非安全！）。理論上，不同步應該最快。
我的測試結果：
轉載文章的結果：
測試結果和轉載文章中差不多，但是synchronized 貌似沒有轉載中說的那麼糟糕。從附圖可以看出：
1、不同步确實最快，與預期一緻。
2、四種同步方式中，ConcurrentHashMap 是最快的，接近不同步的情況。
3、synchronized 關鍵字非常慢
4、使用讀寫鎖的讀鎖，比普通所稍慢。
結論：
1、如果 ConcurrentHashMap 夠用，則使用 ConcurrentHashMap。
2、如果需自己實作同步，則使用 JDK1.5 提供的鎖機制，避免使用 synchronized 關鍵字。
測試代碼：
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;
public class MapTest
{
public static final int THREAD_COUNT = 5;
public static final int MAP_SIZE = 1000;
public static final int EXECUTION_MILLES = 1000;
public static final int[] KEYS = new int[100];
public static void main(String[] args) throws Exception
{
//初始化
Random rand = new Random();
for (int i = 0; i < KEYS.length; ++i)
{
KEYS[i] = rand.nextInt();
}
//建立線程
long start = System.currentTimeMillis();
Thread[] threads = new Thread[THREAD_COUNT];
//生成多個相同的線程
for (int i = 0; i < THREAD_COUNT; ++i)
{
//threads[i] = new UnsafeThread();
threads[i] = new SynchronizedThread();
//threads[i] = new LockThread();
//threads[i] = new ReadLockThread();
//threads[i] = new ConcurrentThread();
threads[i].start();
}
//等待其它線程執行若幹時間
Thread.sleep(EXECUTION_MILLES);
//統計 get 操作的次數
long sum = 0;
for (int i = 0; i < THREAD_COUNT; ++i)
{
//将所有的同類線程通路次數加起來
sum += threads[i].getClass().getDeclaredField("count").getLong(threads[i]);
}
long millisCost = System.currentTimeMillis() - start;
System.out.println(sum + "(" + (millisCost) + "ms)");
System.exit(0);
}
public static void fillMap(Map<Integer, Integer> map)
{
Random rand = new Random();
for (int i = 0; i < MAP_SIZE; ++i)
{
map.put(rand.nextInt(), rand.nextInt());
}
}
}
class UnsafeThread extends Thread
{
private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();
public long count = 0;
static
{
MapTest.fillMap(map);
}
public void run()
{
for (;;)
{
int index = (int)(count % MapTest.KEYS.length);
map.get(MapTest.KEYS[index]);
++count;
}
}
}
class SynchronizedThread extends Thread
{
//所有同類線程共享一個map
private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();
//每個線程使用自己的計數器
public long count = 0;
//o必須是static，否則synchronized(o)每個線程隻對自己的o加鎖，鎖沒有效果
private static final Object o = new Object();
static
{
MapTest.fillMap(map);
}
public void run()
{
for (;;)
{
int index = (int)(count % MapTest.KEYS.length);
// 沒有鎖效果的加鎖方式：
// (1)private final Object o = new Object();
// synchronized(o)
// (2)synchronized(this)
// 有鎖效果的加鎖方式：
// (1)synchronized(map)
// (2)private static final Object o = new Object();
// synchronized(o)
synchronized(SynchronizedThread.class)
{
map.get(MapTest.KEYS[index]);
}
++count;
}
}
}
class LockThread extends Thread
{
private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();
private static Lock lock = new ReentrantLock();
public long count = 0;
static
{
MapTest.fillMap(map);
}
public void run()
{
for (;;)
{
int index = (int)(count % MapTest.KEYS.length);
lock.lock();
map.get(MapTest.KEYS[index]);
lock.unlock();
++count;
}
}
}
class ReadLockThread extends Thread
{
private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();
private static Lock lock = new ReentrantReadWriteLock().readLock();
public long count = 0;
static
{
MapTest.fillMap(map);
}
public void run()
{
for (;;)
{
int index = (int)(count % MapTest.KEYS.length);
lock.lock();
map.get(MapTest.KEYS[index]);
lock.unlock();
++count;
}
}
}
class ConcurrentThread extends Thread
{
private static Map<Integer, Integer> map = new ConcurrentHashMap<Integer, Integer>();
public long count = 0;
static
{
MapTest.fillMap(map);
}
public void run()
{
for (;;)
{
int index = (int)(count % MapTest.KEYS.length);
map.get(MapTest.KEYS[index]);
++count;
}
}
}
補充：
（1）雖然ConcurrentHashMap是線程安全的，而且性能很高，但是
看看下面一段代碼：
ConcurrentHashMap<String,String> map;
String getString(String name) {
String x = map.get(name);
if (x == null) {
x = new String();
map.put(name, x);
}
return x;
}
如果你隻調用get（），或隻調用put（）時，ConcurrentHashMap是線程安全的。
但是，在你調用完get後，調用put之前，
如果有另外一個線程調用了map.put(name, x)，
你再去執行map.put(name,x)，
就很可能把前面的操作結果覆寫掉了。
是以，即使線上程安全的情況下，
你還是有可能違反原子操作的規則。
避免方法：将get和put放到一個鎖下面
Map map = Collections.synchronizedMap(new HashMap());
String getString(String name) {
synchronized(map){//可保證該同步塊内的所有代碼對map是一個原子操作。
String x = map.get(name);
if (x == null) {
x = new String();
map.put(name, x);
}
return x;
}
}
（2）在HashMap中，null可以作為鍵，這樣的鍵隻有一個；可以有一個或多個鍵所對應的值為null。當get()方法傳回null值時，即可以表示HashMap中沒有該鍵，也可以表示該鍵所對應的值為null。是以，在HashMap中不能由get()方法來判斷HashMap中是否存在某個鍵，而應該用containsKey()方法來判斷。