Java——你需要了解一下HashMapHashtableConcurrentHashMap的区别

Posted 2021-06-22 张起灵-小哥

写在前面

听别人说，在面试过程中，面试官经常会问到一个问题： HashMap、Hashtable、ConcurrentHashMap这三者有什么区别？

简单的来说：

• HashMap是线程不安全的，当出现多线程操作时，会出现安全隐患。
• HashTable是线程安全的，其中所有的方法都加上了synchronized关键字，也就是说HashTable用的是方法锁，把整个put方法都上锁了，这就导致了效率很低。如果把put方法比作是一个有很多房间的院子，那么HathTable的锁就相当于是把院子的大门锁上了，导致你进不去这个院子。
• ConcurrentHashMap也是线程安全的，但是它是用的块锁（synchronized关键字修饰的不再是整个方法体，而是部分代码块）。这里仍然把put方法比作一个有很多房间的院子，那么它相当于是把院子里的有安全隐患的房间锁上了，这样一来，其他房间仍然可以进入，只是存在安全隐患的房间你暂时进不去了。

下面，我用三个简单的代码实例来解释一下吧。

HashMap

HashMap是线程不安全的，在源码中对put方法没有做锁的处理，当面对多线程时，会有线程安全问题。

下面通过一个简单的例子进行演示，创建三个线程，并且启动，在run方法里通过for循环给map存100个值，然后输出map的大小按正常来说，该map的大小应该是100，而这里输出了190。

import java.util.HashMap;
import java.util.Map;

/**
 *
 */
public class HashMapTest implements Runnable {

    static Map<String,String> map=new HashMap<>();

    @Override
    public void run() {
        long startTime=System.currentTimeMillis();
        for (int i=0;i<100;i++) {
            map.put(i + "","value");
        }
        long endTime=System.currentTimeMillis();
        System.out.println((endTime-startTime) + "ms");
    }

    public static void main(String[] args) {
        Thread thread1=new Thread(new HashMapTest());
        Thread thread2=new Thread(new HashMapTest());
        Thread thread3=new Thread(new HashMapTest());

        thread1.start();
        thread2.start();
        thread3.start();

        Thread currentThread=Thread.currentThread();
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(map.size());
    }
}

Hashtable

HashTable用到了锁，而且是直接给put方法加的锁，线程肯定是安全的了，这里我们在测试线程安全的同时，看一下执行时间。

import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;

/**
 *
 */
public class HashtableTest implements Runnable {

    static Map<String,String> map=new Hashtable<>();

    @Override
    public void run() {
        long startTime=System.currentTimeMillis();
        for (int i=0;i<100;i++) {
            map.put(i + "","value");
        }
        long endTime=System.currentTimeMillis();
        System.out.println((endTime-startTime) + "ms");
    }

    public static void main(String[] args) {
        Thread thread1=new Thread(new HashtableTest());
        Thread thread2=new Thread(new HashtableTest());
        Thread thread3=new Thread(new HashtableTest());

        thread1.start();
        thread2.start();
        thread3.start();

        Thread currentThread=Thread.currentThread();
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(map.size());
    }
}

这里可以看到，多次反复执行这段代码，最终获取到map集合的size始终是100，不多不少刚刚好，存储的时间大概在12ms左右。

ConcurrentHashMap

ConcurrentHashMap用的是块锁，哪块不安全就锁哪块，不能不锁，不能全锁，那我就块锁！看看这个块锁相对于Hashtable的方法锁是快了，还是慢了。 

import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 *
 */
public class ConcurrentHashMapTest implements Runnable {

    static Map<String,String> map=new ConcurrentHashMap<>();

    @Override
    public void run() {
        long startTime=System.currentTimeMillis();
        for (int i=0;i<100;i++) {
            map.put(i + "","value");
        }
        long endTime=System.currentTimeMillis();
        System.out.println((endTime-startTime) + "ms");
    }

    public static void main(String[] args) {
        Thread thread1=new Thread(new ConcurrentHashMapTest());
        Thread thread2=new Thread(new ConcurrentHashMapTest());
        Thread thread3=new Thread(new ConcurrentHashMapTest());

        thread1.start();
        thread2.start();
        thread3.start();

        Thread currentThread=Thread.currentThread();
        try {
            Thread.sleep(1000);
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(map.size());
    }
}

可以看到，这里最终获取到的map集合的size始终是100，而且存储时间较Hashtable也有一定的缩短，基本在10ms左右。