一、前言
我们知道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针对的是对象。