java Map 读写性能测试

1，Map容器历史

HashTbale jkd1.0 设计理念就是同步线程安全的，所以每个方法都是加了锁的synchronized。但多数的时候都是在单线程工作，这种情况下是不需要线程安全的。

HashMap 完全没有加锁，新的Map容器比HashTbale好用，但是它又没有加锁，怎么让它既支持锁的环境又支持非锁的环境呢？又添加了一个Collections的工具类，其中有一个synchronizedMap会把HashMap变成有锁的版本。

由于设计上的缺陷Vector，HashTbale 基本不用。

HashMap 与HashTbale 区别在于，HashMap 内部声明了一个类用于加锁，虽然也是用的synchronized，但是锁的粒度上更细，效率上略高于HashTbale 。

后期又添加了一个效率更高的Map:ConcurrentHashMap。

2，test code

package com.example.demo.thread.container;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class TestMap {
    public  static  final int COUNT = 1000000;
    public  static  final int THREAD_COUNT = 100;
    //每个线程需要装多少数据到容器中
    public  static  final int NUM = COUNT/THREAD_COUNT;

    static Map<UUID,UUID> j = null;
    static UUID[] keys = new UUID[COUNT];
    static UUID[] values = new UUID[COUNT];
    static Thread[] threads = new Thread[THREAD_COUNT];

    static {
        //先生成数据，是为了避免干扰因素
        for (int i = 0; i < COUNT; i++) {
            keys[i] = UUID.randomUUID();
            values[i] = UUID.randomUUID();
        }
    }

    static class MyWriteThread extends Thread{
        int start;

        public MyWriteThread(int start){this.start = start;}

        @Override
        public void run() {
            for (int i = start; i < start + NUM; i++) {
                j.put( keys[i], values[i]);
            }
        }
    }

    static class MyReadThread extends Thread{
        @Override
        public void run() {
            for (int k = 0; k < COUNT; k++) {
                j.get(keys[k]);
            }
        }
    }

    static void writeTest(){
        //初始化线程的起始值
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new TestMap.MyWriteThread(i*NUM);
        }

        long start = System.currentTimeMillis();
        for (Thread t :threads) {
            t.start();
        }
        //等待每个线程执行结束
        for (Thread t :threads) {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(j.getClass().getSimpleName() +" size:["+j.size()+"] 插入执行时间:["+(System.currentTimeMillis() - start)+"]");
    }

    static void readTest(){
        //设置去读的线程方法
        for (int i = 0; i < threads.length; i++) {
            threads[i] = threads[i] = new TestMap.MyReadThread();
        }

        long start = System.currentTimeMillis();
        for (Thread t :threads) {
            t.start();
        }
        //等待每个线程执行结束
        for (Thread t :threads) {
            try {
                t.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(j.getClass().getSimpleName() +" size:["+j.size()+"] 查询执行时间:["+(System.currentTimeMillis() - start)+"]");
    }


    static void  writeAndReadTest(){
        writeTest();
        readTest();
    }

    public static void main(String[] args) {
        j =  new Hashtable();
        writeAndReadTest();

        /**
         * 由于非同步的HashMap在多线程下，无法插入我们预期的数量，所以比较就没有意义
         * 故直接采取同步的HashMap做对比
         */
        j = Collections.synchronizedMap(new HashMap());
        writeAndReadTest();

        j = new ConcurrentHashMap();
        writeAndReadTest();
    }
}

3，Console：

Hashtable size:[1000000] 插入执行时间:[303]
Hashtable size:[1000000] 查询执行时间:[9330]
SynchronizedMap size:[1000000] 插入执行时间:[284]
SynchronizedMap size:[1000000] 查询执行时间:[9107]
ConcurrentHashMap size:[1000000] 插入执行时间:[554]
ConcurrentHashMap size:[1000000] 查询执行时间:[2068]

4，结论

	Hashtable	HashMap	ConcurrentHashMap
write	教快	最快	最慢
read	最慢	较快	最快

Hashtable 和HashMap的对比中，可以看出是HashMap完胜了；

在非同步下，首选肯定是HashMap；

在同步情况下，肯定选ConcurrentHashMap，因为实际成产中，读的场景比写的场景更频繁。

当然这并不是绝对的，绝体取决你的具体场景。

到底是使用SynchronizedMap还是ConcurrentHashMap？本质上是Synchronized和CAS的取舍。

CAS                (自旋/无锁/乐观锁) ：线程多，操作时间短的情况下，自旋锁大于系统锁的性能

Synchronized（系统锁）              ：线程少，操作时间长的情况下，系统锁的性能大于自旋锁

还有一个重要的指标，就是实际环境的压测。