ConcurrentMap并发容器对比

JDK5.0之后提供了多种并发类容器可以替代同步类容器，提升性能、吞吐量

ConcurrentHashMap替代HashMap、HashTable

ConcurrentSkipListMap替代TreeMap

简单原理：

并发情况下，验证提高性能

一、ConcunrrentHashMap

public class Test {
    //这是main方法，程序的入口
    public static void main(String[] args) {
        //选择一个容器：
        ConcurrentHashMap<String,Integer> map = new ConcurrentHashMap<>();
        
        //创建10个线程：
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    long startTime = System.currentTimeMillis();
                    for (int j = 0; j < 1000000; j++) {
                        map.put("test" + j , j);
                    }
                    long endTime = System.currentTimeMillis();
                    System.out.println("一共需要的时间：" + (endTime - startTime));
                }
            }).start();
        }
    }
}

​

结果：

​

二、Hashtable

package com.lanson.test03;

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

/**
 * @author : lanson
 */
public class Test {
    //这是main方法，程序的入口
    public static void main(String[] args) {
        //选择一个容器：
        //ConcurrentHashMap<String,Integer> map = new ConcurrentHashMap<>();
        Hashtable map = new Hashtable();
        //创建10个线程：
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    long startTime = System.currentTimeMillis();
                    for (int j = 0; j < 1000000; j++) {
                        map.put("test" + j , j);
                    }
                    long endTime = System.currentTimeMillis();
                    System.out.println("一共需要的时间：" + (endTime - startTime));
                }
            }).start();
        }
    }
}

​

结果：

三、HashMap

package com.lanson.test03;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author : lanson
 */
public class Test {
    //这是main方法，程序的入口
    public static void main(String[] args) {
        //选择一个容器：
        //ConcurrentHashMap<String,Integer> map = new ConcurrentHashMap<>();
        //Hashtable map = new Hashtable();
        HashMap map = new HashMap();
        //创建10个线程：
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    long startTime = System.currentTimeMillis();
                    for (int j = 0; j < 1000000; j++) {
                        map.put("test" + j , j);
                    }
                    long endTime = System.currentTimeMillis();
                    System.out.println("一共需要的时间：" + (endTime - startTime));
                }
            }).start();
        }
    }
}

​

结果：

四、线程安全的HashMap

package com.lanson.test03;

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

/**
 * @author : lanson
 */
public class Test {
    //这是main方法，程序的入口
    public static void main(String[] args) {
        //选择一个容器：
        //ConcurrentHashMap<String,Integer> map = new ConcurrentHashMap<>();
        //Hashtable map = new Hashtable();
        HashMap oldmap = new HashMap();
        Map map = Collections.synchronizedMap(oldmap);
        //创建10个线程：
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    long startTime = System.currentTimeMillis();
                    for (int j = 0; j < 1000000; j++) {
                        map.put("test" + j , j);
                    }
                    long endTime = System.currentTimeMillis();
                    System.out.println("一共需要的时间：" + (endTime - startTime));
                }
            }).start();
        }
    }
}

​

结果：

五、总结

ConcurrentHashMap：性能高，线程安全

Hashtable: 线程安全，性能低

HashMap:线程不安全，性能高

线程安全的HashMap：线程安全，性能低

​