Map集合--JDK1.7中ConcurrentHashMap和JDK1.8中ConcurrentHashMap的理解

一、前言

我们知道JDK1.7当中ConcurrentHashMap和JDK1.8当中ConcurrentHashMap实现的方式不同，JDK1.7当中ConcurrentHashMap使用的是Segment实现ReentranLock锁分段的方式来控制并发结果的正确性，而JDK1.8当中采用的是synchronized+CAS的方式控制对HashMap的并发访问。
这两种方式的不同点在于我们使用Segment锁住的Map的粒度是一个或者多个Bin，而对于使用synchronized的方式锁住的是某一个Bin的头结点，相当于锁住了这一整个Bin(因为不管我们是使用put方法还是get方法，我们必须从头结点开始遍历)。因此我们可以知道，对于高并发场景，JDK1.8的性能会更加高效。

二、测试代码

这是我的一个测试，我向一个List中添加了两个对象，Thread3会开启一个线程锁住一个对象，而Thread4会开启一个线程锁住另一个对象。类比于ConcurrentHasMap中的我们不同的线程去put对象的时候，锁住的只是某一个bin。而不是整个HashMap或者（JDK1.7中的CurrentHashMap锁住的一个Segment，这里我需要去了解一下Segment应该是一个存有多个List的数组）。

package Concurrence;

import java.util.ArrayList;
import java.util.List;

public class LikeJava_8ConconcurrentHashMapTest {
    public static void main(String[] args){
        LikeHashMap likeHashMap = new LikeHashMap();
        likeHashMap.initalList();
        Thread3 thread3 = new Thread3(likeHashMap);
        Thread4 thread4 = new Thread4(likeHashMap);
        thread3.start();
        thread4.start();
    }
}
class LikeHashMap{
    List<Object> list = new ArrayList<Object>();
    public void testMethod(int i){
        Object object = list.get(i);
        synchronized (object){
            System.out.println(Thread.currentThread().getName()+"进入了testMethod()"+  "  :  "+System.currentTimeMillis());
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"休眠5s钟后退出了testMethod()"+  "  :  "+System.currentTimeMillis());
        }
    }
    public void initalList(){
        for(int i = 0;i<2;i++){
            list.add(new Object());
        }
    }
}

class Thread3 extends Thread{
    private LikeHashMap likeHashMap;
    public  Thread3(LikeHashMap likeHashMap){
        this.likeHashMap = likeHashMap;
    }

    @Override
    public void run(){
        likeHashMap.testMethod(0);
    }
}
class Thread4 extends Thread{
    private LikeHashMap likeHashMap;
    public Thread4(LikeHashMap likeHashMap){
        this.likeHashMap = likeHashMap;
    }

    @Override
    public void run(){
        likeHashMap.testMethod(1);
    }
}

输出结果

Thread-0进入了testMethod()  :  1532941912771
Thread-1进入了testMethod()  :  1532941912772
Thread-0休眠5s钟后退出了testMethod()  :  1532941917772
Thread-1休眠5s钟后退出了testMethod()  :  1532941917772

从这个结果我们可以看到，我们的两个线程是异步访问List集合中的两个不同的对象，但是是同时访问同一个对象的同一个方法。如果想分段锁，我们锁住的是线程，并不是什么对象锁。所以以前看到的锁ReentranLock锁住的是对象，其实不是，ReentranLock是只是将线程作为独占的那个线程，并没有锁住对象。ReentranLock针对的是线程，而synchronized针对的是对象。