JAVA-JDK1.7-ConCurrentHashMap-测试和验证

概述

上次记录了关于ConCurrentHashMap的原理以及源码，现在我对其进行有关功能的测试，下面就讲解一下我测试的内容和代码。这些测试主要针对JDK1.7版本。

GET安全测试

上一篇写过get方法是没有加锁的，因为HashEntry的value和next属性是volatile的，volatile直接保证了可见性，所以读的时候可以不加锁，现在写一个程序，启动20个线程，只有一个key="count",每个线程都要执行 map.put(key, 1)  或者 map.put(key, value + 1) ，所以理论上说，20个线程会得到值（"count",20）,所有的源码如下：

package test;

import java.io.Serializable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Created by Administrator on 2019/12/4.
 */
public class TestConcurrentHashMap {


    public static void main(String[] args) {
        DoWork dw = new DoWork(map);
        //map.put("1",1);
        ExecutorService pool = Executors.newFixedThreadPool(8);
        try {
            for (int i = 0; i < 20; i++) {
                pool.execute(new Thread(dw));// 开启20个线程
            }
            Thread.sleep(5000);// 主线程睡眠5s 等待子线程完成任务
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            pool.shutdown();// 关闭线程池
        }
        System.out.println("统计的数量：" + map.get("count"));

    }
    private static ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();

    static class DoWork  extends ReentrantLock implements Serializable,Runnable {

        private ConcurrentHashMap<String, Integer> map = null;

        public DoWork(ConcurrentHashMap<String, Integer> map) {
            this.map = map;
        }

        @Override
        public void run() {
            add("count");
        }

        public void add(String key) {
            Integer value = map.get(key);// 获取map中的数值
            System.out.println("当前数量" + value);
            if (null == value) {
                map.put(key, 1);// 第一次存放
            } else {
                map.put(key, value + 1);// 以后次存放
            }
        }
        public void addLock(String key) {
            lock();
            try {
                Integer value = map.get(key);
                System.out.println("当前数量" + value);
                if (null == value) {
                    map.put(key, 1);
                } else {
                    map.put(key, value + 1);
                }
            } finally {
                unlock();
            }
        }



    }

}

在如上测试代码中有如下问题：

问题1：为什么开启20个线程，启动的线程池确是8个 见第18行 21行代码？ 

回答：这样可以更大的概率实现线程并发。也就是更容易出现问题。

问题2：为什么要睡眠5s，

回答：那是因为统计结果的时候尽量确认所有线程执行完了，结果更加准确。

问题3：ReentrantLock 方法是干嘛的？

回答：ReentrantLock实现了独占功能，是这里使用的原因。

当在线程run方法中执行add(String key)方法时候，执行结果如下：

 明显有问题的说，put是有锁的，所以先猜测get存在不安全的嫌疑，现在查看get方法源码，说明get确实没有加锁。所以说明的问题是虽然put有原子性，但是get+put就没有原子性，也就是说，当第一个线程get一个值之后，还没有put进去的时候，就被第二个线程get了，所以第二个线程get的值就是第一个线程put之前的值。

public V get(Object key) {
        Segment<K,V> s; // manually integrate access methods to reduce overhead
        HashEntry<K,V>[] tab;
        int h = hash(key);
        long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
        if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
            (tab = s.table) != null) {
            for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
                     (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
                 e != null; e = e.next) {
                K k;
                if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                    return e.value;
            }
        }
        return null;
    }

现在对add方法执行加锁方法，执行测试代码的56行代码的addLock方法。

然后debug输出是：

 并发效率测试

现在模拟1000个并发，每个测试1000次操作，循环测试10轮。分别测试Put和Get操作，测试对象HashMapSync、ConcurrentHashMap、Hashtable。源码如下：

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

import static javafx.scene.input.KeyCode.T;


/**
 * 测试HashMap和ConcurrentHashMap的并发性能差别。
 *
 *
 */
public class TestConCurrent {
    static final int threads = 1000;
    static final int NUMBER = 1000;

    public static void main(String[] args) throws Exception {
        Map<String, Integer> hashmapSync = Collections
                .synchronizedMap(new HashMap<String, Integer>());
        Map<String, Integer> concurrentHashMap = new ConcurrentHashMap<String, Integer>();
        Map<String, Integer> hashtable = new Hashtable<String, Integer>();
        long totalA = 0;
        long totalB = 0;
        long totalC = 0;
        for (int i = 0; i <= 10; i++) {
            totalA += testPut(hashmapSync);
            totalB += testPut(concurrentHashMap);
            totalC += testPut(hashtable);
        }
        System.out.println("Put time HashMapSync=" + totalA + "ms.");
        System.out.println("Put time ConcurrentHashMap=" + totalB + "ms.");
        System.out.println("Put time Hashtable=" + totalC + "ms.");
        totalA = 0;
        totalB = 0;
        totalC = 0;
        for (int i = 0; i <= 10; i++) {
            totalA += testGet(hashmapSync);
            totalB += testGet(concurrentHashMap);
            totalC += testGet(hashtable);
        }
        System.out.println("Get time HashMapSync=" + totalA + "ms.");
        System.out.println("Get time ConcurrentHashMap=" + totalB + "ms.");
        System.out.println("Get time Hashtable=" + totalC + "ms.");
    }
    public static long testPut(Map<String, Integer> map) throws Exception {
        long start = System.currentTimeMillis();
        for (int i = 0; i < threads; i++) {
            new MapPutThread(map).start();
        }
        while (MapPutThread.counter > 0) {
            Thread.sleep(1);
        }
        return System.currentTimeMillis() - start;
    }
    public static long testGet(Map<String, Integer> map) throws Exception {
        long start = System.currentTimeMillis();
        for (int i = 0; i < threads; i++) {
            new MapGetThread(map).start();
        }
        while (MapGetThread.counter > 0) {
            Thread.sleep(1);
        }
        return System.currentTimeMillis() - start;
    }
}
class MapPutThread extends Thread {
    static int counter = 0;
    static Object lock = new Object();
    private Map<String, Integer> map;
    private String key = this.getId() + "";
    MapPutThread(Map<String, Integer> map) {
        synchronized (lock) {
            counter++;
        }
        this.map = map;
    }
    public void run() {
        for (int i = 1; i <= TestConCurrent.NUMBER; i++) {
            map.put(key, i);
        }
        synchronized (lock) {
            counter--;
        }
    }
}
class MapGetThread extends Thread {
    static int counter = 0;
    static Object lock = new Object();
    private Map<String, Integer> map;
    private String key = this.getId() + "";
    MapGetThread(Map<String, Integer> map) {
        synchronized (lock) {
            counter++;
        }
        this.map = map;
    }
    public void run() {
        for (int i = 1; i <= TestConCurrent.NUMBER; i++) {
            map.get(key);
        }
        synchronized (lock) {
            counter--;
        }
    }
}

如上代码只是测试效率的简单测试： 

测试结果是：

总结

能动手的尽量不要猜，能用代码的尽量不要相信原理。

感谢网络大神，参考链接：

https://blog.csdn.net/java2000_net/article/details/3373181

https://www.cnblogs.com/yanphet/p/5726919.html