如何在线程安全的情况下使用HashMap？_5.描述一下hashtable和hashmap,在线程安全的场景下使用hashmap有哪些常用方法。-优快云博客

前一篇文章分析了HashMap是线程不安全的及其原因，那么如何在线程安全的情况下使用HashMap呢？

原文出处： Giraffe

了解了HashMap为什么线程不安全，那现在看看如何线程安全的使用HashMap。这个无非就是以下三种方式：

Hashtable
ConcurrentHashMap
Synchronized Map

例子：

//Hashtable

Map<String, String> hashtable = new Hashtable<>();



//synchronizedMap

Map<String, String> synchronizedHashMap = Collections.synchronizedMap(new HashMap<String, String>());



//ConcurrentHashMap

Map<String, String> concurrentHashMap = new ConcurrentHashMap<>();

依次来看看。

Hashtable

先稍微吐槽一下，为啥命名不是HashTable啊，看着好难受，不管了就装作它叫HashTable吧。这货已经不常用了，就简单说说吧。HashTable源码中是使用synchronized来保证线程安全的，比如下面的get方法和put方法：

所以当一个线程访问HashTable的同步方法时，其他线程如果也要访问同步方法，会被阻塞住。举个例子，当一个线程使用put方法时，另一个线程不但不可以使用put方法，连get方法都不可以，好霸道啊！！！so~~，效率很低，现在基本不会选择它了。

ConcurrentHashMap

ConcurrentHashMap(以下简称CHM)是JUC包中的一个类，Spring的源码中有很多使用CHM的地方。之前已经翻译过一篇关于ConcurrentHashMap的博客，如何在java中使用ConcurrentHashMap，里面介绍了CHM在Java中的实现，CHM的一些重要特性和什么情况下应该使用CHM。需要注意的是，上面博客是基于Java 7的，和8有区别,在8中CHM摒弃了Segment（锁段）的概念，而是启用了一种全新的方式实现,利用CAS算法，有时间会重新总结一下。

SynchronizedMap

看了一下源码，SynchronizedMap的实现还是很简单的。

从源码中可以看出调用synchronizedMap()方法后会返回一个SynchronizedMap类的对象，而在SynchronizedMap类中使用了synchronized同步关键字来保证对Map的操作是线程安全的。

性能对比

这是要靠数据说话的时代，所以不能只靠嘴说CHM快，它就快了。写个测试用例，实际的比较一下这三种方式的效率(源码来源)，下面的代码分别通过三种方式创建Map对象，使用ExecutorService来并发运行5个线程，每个线程添加/获取500K个元素。

public class CrunchifyConcurrentHashMapVsSynchronizedMap {



    public final static int THREAD_POOL_SIZE = 5;



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

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

    public static Map<String, Integer> crunchifyConcurrentHashMapObject = null;



    public static void main(String[] args) throws InterruptedException {



        // 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 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() {

                    @SuppressWarnings("unused")

                    @Override

                    public void run() {



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

                            Integer crunchifyRandomNumber = (int) Math.ceil(Math.random() * 550000);



                            // Retrieve value. We are not using it anywhere

                            Integer crunchifyValue = crunchifyThreads.get(String.valueOf(crunchifyRandomNumber));



                            // Put value

                            crunchifyThreads.put(String.valueOf(crunchifyRandomNumber), crunchifyRandomNumber);

                        }

                    }

                });

            }



            // 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");

    }

}

测试结果：

Test started for: class java.util.Hashtable

2500K entried added/retrieved in 2018 ms

2500K entried added/retrieved in 1746 ms

2500K entried added/retrieved in 1806 ms

2500K entried added/retrieved in 1801 ms

2500K entried added/retrieved in 1804 ms

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



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

2500K entried added/retrieved in 3041 ms

2500K entried added/retrieved in 1690 ms

2500K entried added/retrieved in 1740 ms

2500K entried added/retrieved in 1649 ms

2500K entried added/retrieved in 1696 ms

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



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

2500K entried added/retrieved in 738 ms

2500K entried added/retrieved in 696 ms

2500K entried added/retrieved in 548 ms

2500K entried added/retrieved in 1447 ms

2500K entried added/retrieved in 531 ms

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

CHM性能是明显优于Hashtable和SynchronizedMap的,CHM花费的时间比前两个的一半还少