如何实现线程的HashMap以及性能对比

对于线程是否是安全的问题，一般是不会用到的，因为在开发中通用的是单线程倒是不用担心线程安全问题。

但是对于要进行高并发的开发，线程安全就必不可少了，这也是面试的拦路虎，在此总结一下前人的经验，进行线程安全的总结，如有不足的地方请指出交流。

借鉴别人的测试代码并完善一下:

import java.util.Collections;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

public class CrunchifyConcurrentHashMapVsSynchronizedMap {

public final static int THREAD_POOL_SIZE = 10;
public final static int THREAD_LOOP_TIME = 100000;
public final static String key = "wordcounts" ;

public static Map<String, AtomicLong> crunchifyHashTableObject = null;

public static Map<String, AtomicLong> crunchifySynchronizedMapObject = null;

public static Map<String, AtomicLong> crunchifyConcurrentHashMapObject = null;
public static Map<String, AtomicLong> crunchifyHashMapObject = null;

public static void main(String[] args) throws

InterruptedException {
// 安全性测试
mapSecurictyTest();
//效率测试
mapEfficienceTest();
}

private static void mapSecurictyTest() throws InterruptedException {
// Test with HashMap Object
crunchifyHashMapObject = new HashMap<>();
threadSecurityTest(crunchifyHashMapObject);

// Test with Hashtable Object
crunchifyHashTableObject = new Hashtable<>();
threadSecurityTest(crunchifyHashTableObject);

// Test with synchronizedMap Object
crunchifySynchronizedMapObject = Collections.synchronizedMap(new HashMap<String, AtomicLong>());
threadSecurityTest(crunchifySynchronizedMapObject);

// Test with ConcurrentHashMap Object
crunchifyConcurrentHashMapObject = new ConcurrentHashMap<>();
threadSecurityTest(crunchifyConcurrentHashMapObject);

}

private static void mapEfficienceTest() throws InterruptedException {

// 效率最高 38ms
Map<String, Integer> crunchifyHashMapObject = null;

//	For class java.util.Hashtable the average time is 82 ms
Map<String, Integer> crunchifyHashTableObject = null;
//	For class java.util.Collections$SynchronizedMap the average time is 84 ms
Map<String, Integer> crunchifySynchronizedMapObject = null;
//	For class java.util.concurrent.ConcurrentHashMap the average time is 58 ms
Map<String, Integer> crunchifyConcurrentHashMapObject = null;

// Test with HashMap Object
crunchifyHashMapObject = new HashMap<>();
crunchifyPerformTest(crunchifyHashMapObject);

// Test with Hashtable Object
crunchifyHashTableObject = new Hashtable<>();
crunchifyPerformTest(crunchifyHashTableObject);

// Test with synchronizedMap Object
crunchifySynchronizedMapObject = Collections.synchronizedMap(new HashMap<String, Integer>());
crunchifyPerformTest(crunchifySynchronizedMapObject);

// Test with ConcurrentHashMap Object
crunchifyConcurrentHashMapObject = new ConcurrentHashMap<>();
crunchifyPerformTest(crunchifyConcurrentHashMapObject);
}

public static void threadSecurityTest( final Map<String, AtomicLong> map) throws InterruptedException {

System.out.println("Test started for: " + map.getClass());
long averageTime = 0;
for (int i = 0; i < 5; i++) {
long startTime = System.nanoTime();
ExecutorService crunchifyExServer = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
for (int j = 0; j < THREAD_POOL_SIZE; j++) {
crunchifyExServer.execute(new Runnable() {
@Override
public void run() {

for (int i = 0; i < THREAD_LOOP_TIME; i++) {
AtomicLong number = map.get(key);
if (number == null) {
AtomicLong newNumber = new AtomicLong(0);
number = map.putIfAbsent(key, newNumber);
if (number == null) {
number = newNumber;
}
}
long incrementValue = number.incrementAndGet();

if ((incrementValue )%500000==00) {
System.out.println("value is :" +(incrementValue ));
}

}
}
});
}

// Make sure executor stops
crunchifyExServer.shutdown();
// Blocks until all tasks have completed execution after a shutdown  request
crunchifyExServer.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);

long entTime = System.nanoTime();
long totalTime = (entTime - startTime) / 1000000L;
averageTime += totalTime;

System.out.println( (i+1 )+"-"+THREAD_POOL_SIZE*THREAD_LOOP_TIME +" entried added/retrieved in " + totalTime + " ms");
}
System.out.println("For " + map.getClass() + " the average time is " + averageTime / 5 + " ms\n");
}

public static void crunchifyPerformTest( final Map<String, Integer> crunchifyThreads) throws InterruptedException {

System.out.println("Test started for: " + crunchifyThreads.getClass());

long averageTime = 0;

for (int i = 0; i < 5; i++) {

long startTime = System.nanoTime();
ExecutorService crunchifyExServer = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
for (int j = 0; j < THREAD_POOL_SIZE; j++) {

crunchifyExServer.execute(new Runnable() {

@Override
public void run() {

for (int i = 0; i < THREAD_LOOP_TIME; i++) {

// Retrieve value. We are not using it anywhere
Integer crunchifyValue = crunchifyThreads.get(key);

// Put value
crunchifyThreads.put( key, new Integer(1));
}
}
});
}
// Make sure executor stops
crunchifyExServer.shutdown();
// Blocks until all tasks have completed execution after a shutdown  request
crunchifyExServer.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);

long entTime = System.nanoTime();
long totalTime = (entTime - startTime) / 1000000L;
averageTime += totalTime;

System.out.println("2500K entried added/retrieved in " + totalTime + " ms");
}
System.out.println("For " + crunchifyThreads.getClass() + " the average time is " + averageTime / 5 + " ms\n");
}

}

测试结果：
由打印结果发现 HashMap居然能够累加到500w.难道HashMap也能线程安全吗？

================================== map securicty test start ==================================

Test started for: class java.util.HashMap

value is :500000

value is :1000000

1-1000000 entried added/retrieved in 57 ms

value is :1500000

value is :2000000

2-1000000 entried added/retrieved in 51 ms

value is :2500000

value is :3000000

3-1000000 entried added/retrieved in 38 ms

value is :3500000

value is :4000000

4-1000000 entried added/retrieved in 35 ms

value is :4500000

value is :5000000

5-1000000 entried added/retrieved in 35 ms

For class java.util.HashMap the average time is 43 ms

Test started for: class java.util.Hashtable

value is :500000

value is :1000000

1-1000000 entried added/retrieved in 97 ms

value is :1500000

value is :2000000

2-1000000 entried added/retrieved in 66 ms

value is :2500000

value is :3000000

3-1000000 entried added/retrieved in 67 ms

value is :3500000

value is :4000000

4-1000000 entried added/retrieved in 65 ms

value is :4500000

value is :5000000

5-1000000 entried added/retrieved in 61 ms

For class java.util.Hashtable the average time is 71 ms

Test started for: class java.util.Collections$SynchronizedMap

value is :500000

value is :1000000

1-1000000 entried added/retrieved in 111 ms

value is :1500000

value is :2000000

2-1000000 entried added/retrieved in 90 ms

value is :2500000

value is :3000000

3-1000000 entried added/retrieved in 92 ms

value is :3500000

value is :4000000

4-1000000 entried added/retrieved in 94 ms

value is :4500000

value is :5000000

5-1000000 entried added/retrieved in 98 ms

For class java.util.Collections$SynchronizedMap the average time is 97 ms

Test started for: class java.util.concurrent.ConcurrentHashMap

value is :500000

value is :1000000

1-1000000 entried added/retrieved in 40 ms

value is :1500000

value is :2000000

2-1000000 entried added/retrieved in 35 ms

value is :2500000

value is :3000000

3-1000000 entried added/retrieved in 32 ms

value is :3500000

value is :4000000

4-1000000 entried added/retrieved in 34 ms

value is :4500000

value is :5000000

5-1000000 entried added/retrieved in 33 ms

For class java.util.concurrent.ConcurrentHashMap the average time is 34 ms

================================== map securicty test end ==================================

带着疑问再次进行单独测试：

Test started for: class java.util.HashMap

value is :500000

1-1000000 entried added/retrieved in 51 ms

value is :1000000

value is :1500000

2-1000000 entried added/retrieved in 40 ms

value is :2000000

value is :2500000

3-1000000 entried added/retrieved in 31 ms

value is :3000000

value is :3500000

4-1000000 entried added/retrieved in 30 ms

value is :4000000

value is :4500000

5-1000000 entried added/retrieved in 30 ms

For class java.util.HashMap the average time is 36 ms

发现这次就没有能够达到线程安全。

所以线程安全的策略有三种，而且要和atomic结合操作才能实现。

效率测试如下：

HashMap的效率最高，如果不考虑线程的问题（单线程使用的时候），HashMap是首选。

其次是ConcurrentHashMap，Collections$SynchronizedMap,Hashtable 。

一般情况下ConcurrentHashMap效率能够达到Collections$SynchronizedMap或者Hashtable 的两倍，

================================== map Efficience test start ==================================

Test started for: class java.util.HashMap

2500K entried added/retrieved in 58 ms

2500K entried added/retrieved in 49 ms

2500K entried added/retrieved in 26 ms

2500K entried added/retrieved in 27 ms

2500K entried added/retrieved in 28 ms

For class java.util.HashMap the average time is 37 ms

Test started for: class java.util.Hashtable

2500K entried added/retrieved in 113 ms

2500K entried added/retrieved in 76 ms

2500K entried added/retrieved in 72 ms

2500K entried added/retrieved in 75 ms

2500K entried added/retrieved in 74 ms

For class java.util.Hashtable the average time is 82 ms

Test started for: class java.util.Collections$SynchronizedMap

2500K entried added/retrieved in 100 ms

2500K entried added/retrieved in 87 ms

2500K entried added/retrieved in 88 ms

2500K entried added/retrieved in 84 ms

2500K entried added/retrieved in 87 ms

For class java.util.Collections$SynchronizedMap the average time is 89 ms

Test started for: class java.util.concurrent.ConcurrentHashMap

2500K entried added/retrieved in 63 ms

2500K entried added/retrieved in 58 ms

2500K entried added/retrieved in 58 ms

2500K entried added/retrieved in 57 ms

2500K entried added/retrieved in 60 ms

For class java.util.concurrent.ConcurrentHashMap the average time is 59 ms

================================== map Efficience test end ==================================

参考： http://blog.csdn.net/cnhk1225/article/details/52413201