ConcurrentHashMap并不是绝对线程安全的

ConcurrentHashMap是线程安全的概念已经深入人心，让我们在使用的时候有些大意了，我也懒得动脑子，直接使用，结果碰到钉子了. 
这个问题让我很郁闷，程序逻辑全是对的，但是问题却明明摆在那边，最后怀疑是HashMap的问题。 

package com.taobao.mmp.test;

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

import com.taobao.mmp.dataobject.ServiceDO;

public class TTTT {

    private static Map<Long, ServiceDO> widgetCacheMap = new ConcurrentHashMap<Long, ServiceDO>();
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        for(int i=0;i<10000;i++){
            Thread tt = new Thread(new Rund());
            tt.start();
        }
    }

    static class Rund implements Runnable{

        public void run() {
            // TODO Auto-generated method stub
            test();
        }

        /**
         * 1W次，总有那么几次线程不安全
         */
        public void test(){
                TTTT tt = new TTTT();
                tt.set();
                int s1 = widgetCacheMap.get(1L).getStatus();
                tt.change();
                int s2 = widgetCacheMap.get(1L).getStatus();
                if(s1==s2){
                    System.out.println(s1+":"+s2);
                }
        }

    }



    public void set() {
            Map mm= new HashMap();
            ServiceDO ss = new ServiceDO();
            ss.setStatus(1);
            mm.put(1L, ss);
            widgetCacheMap = mm;
    }
    public void change(){
            Map mm= new HashMap();
            ServiceDO ss = new ServiceDO();
            ss.setStatus(2);
            mm.put(1L, ss);
            widgetCacheMap = mm;
    }

}

执行10000次，多执行几次，或许你会发现，真的一般情况下是线程安全的，但是在大量并发的时候，线程就变得不那么安全了. 
输出结果如下: 

2:2
2:2
2:2

为什么出现这种情况，我在第一个地方设置值，然后取值，第二个地方再设置值，然后取值，两个值应该不同的，判断相同的时候，既然出现了。有人怀疑是ConcurrentHashMap,那你可以换成HashMap试试.结果一样. 
为什么是2,2不是1,1；当然一般情况下是1:2，并发情况下就变成2,2了. 
有人怀疑是初始化widgetCacheMap的问题，那么改代码如下: 

public void set() {
        //Map mm= new HashMap();
        ServiceDO ss = new ServiceDO();
        ss.setStatus(1);
        widgetCacheMap.put(1L, ss);
        //widgetCacheMap = mm;
}
public void change(){
        //Map mm= new HashMap();
        ServiceDO ss = new ServiceDO();
        ss.setStatus(2);
        widgetCacheMap.put(1L, ss);
        //widgetCacheMap = mm;
}

真是不改不知道，一改吓一跳，这回出现刚才说的情况1,1 

1:1
2:2
2:2
2:2
2:2

而且改了之后其并发问题更严重了，因为这里每一次put都需要加行锁，其并发的概念也就上升了. 
推荐写法还是按第一次方法，对象的覆盖是原子的，最好加一把锁，否则你第一次覆盖了，第二次又被别人覆盖了. 
于是代码如下: 

public void set() {
    synchronized (widgetCacheMap) {

        Map mm= new HashMap();
        ServiceDO ss = new ServiceDO();
        ss.setStatus(1);
        mm.put(1L, ss);
        widgetCacheMap = mm;

    }
}
public void change(){
    synchronized (widgetCacheMap) {
        Map mm= new HashMap();
        ServiceDO ss = new ServiceDO();
        ss.setStatus(2);
        mm.put(1L, ss);
        widgetCacheMap = mm;
    }

}

保持widgetCacheMap的变更成原子状态。当然还会出现上面的情况，这是为什么呢。 
因为每一个线程获取的时候，可能取的是原子1,也可能是原子2,如果在多线程获取的时候加一把锁，那么获取的就是原子X,但至少是一个原子，要么1,要么2. 
于是代码如下: 

public void test(){
        synchronized (widgetCacheMap) {
            TTTT tt = new TTTT();
            tt.set();
            int s1 = widgetCacheMap.get(1L).getStatus();
            tt.change();
            int s2 = widgetCacheMap.get(1L).getStatus();
            if(s1==s2){
                System.out.println(s1+":"+s2);
            }
        }
    }

结果又出现如上现象，这是为什么呢，因为锁里面还加着锁，锁最好是原子化，尽量保持最小范围，不能价懒，像我一样就悲剧了. 

/**
 * 1W次，总有那么几次线程不安全
 */
public void test(){
        TTTT tt = new TTTT();
        tt.set();
        int s1 = -1;
        synchronized (widgetCacheMap) {
          s1 = widgetCacheMap.get(1L).getStatus();
        }
        tt.change();
        int s2 = -2;
        synchronized (widgetCacheMap) {
          s2 = widgetCacheMap.get(1L).getStatus();
        }
        if(s1==s2){
            System.out.println(s1+":"+s2);
        }
}

还是出现上面这种情况，通阅全码，发现每一次都是原子了，应该没问题了。 
但是还需要考虑run方法是多线程的，只有一个线程进入test，那就算原子了.如下: 
唉，这是为什么呢，syn不起作用？ 
开始怀疑，于是去掉所有的syn，只添加run方法中的如下: 

/**
     * 1W次，总有那么几次线程不安全
     */
    public   void test(){
        synchronized (widgetCacheMap) {
            TTTT tt = new TTTT();
            tt.set();
            int s1 = -1;

              s1 = widgetCacheMap.get(1L).getStatus();
            tt.change();
            int s2 = -2;
              s2 = widgetCacheMap.get(1L).getStatus();

            if(s1==s2){
                System.out.println(s1+":"+s2);
            }
        }
    }

整个进行原子操作，结果让人晕死。还是出现在，最后想了想，原来Hash或者CurrentHashMap也一样，在中间change了一下，而syn锁定的是一个不变的东西。 
于如改代码如下: 

/**
     * 1W次，总有那么几次线程不安全
     */
    public   void test(){
        synchronized ("") {
            TTTT tt = new TTTT();
            tt.set();
            int s1 = -1;

              s1 = widgetCacheMap.get(1L).getStatus();
            tt.change();
            int s2 = -2;
              s2 = widgetCacheMap.get(1L).getStatus();

            if(s1==s2){
                System.out.println(s1+":"+s2);
            }
        }
    }

这回你怎么执行都是原子操作了。 

总结：ConcurrentHashMap是线程安全的，那是在他们的内部操作，其外部操作还是需要自己来保证其同步的，特别是静态的ConcurrentHashMap,其有更新和查询的过程，要保证其线程安全，需要syn一个不可变的参数才能保证其原子性