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一个不可变的参数才能保证其原子性

评论

10 楼 james_lover 2014-08-07  

看标题还以为是jdk发现Bug了。 博主太坑了。

9 楼 793059909 2014-06-01  

xinyiwust 写道

今天无意中看到你这篇博客，我觉得有问题：
    1.widgetCacheMap = mm
你这样一来，widgetCacheMap指向了一个HashMap,它已经不是一个ConcurrentHashMap了；
    2.ConcurrentHashMap本身确实是一个线程安全的数据结构，但它的线程安全是有条件的，你的这个test方法：    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); 
                } 
        }
本身是有问题的，假如某一个线程刚执行完tt.set()中的 widgetCacheMap.put(1L,ss);然后另个线程立刻开始执行tt.change()中的 widgetCacheMap.put(1L,ss);并且执行完毕，那么第一个数就变成了2，同理第二个数也可能变成1.

这个测试用例是有问题的，有事务的意途，但没有事务的约束，
你测的不是ConcurrentHashMap，而是两个set和change的事务性保证

8 楼 793059909 2014-06-01  

是set方法没有同步：
        public synchronized void run() { 
            // TODO Auto-generated method stub 
          test(); 
        } 

7 楼 风驰电掣ljp 2014-05-23  

有意思吗？

6 楼 wx65 2013-03-06  

这个和concurrentmap没有关系，类安全的范围都只有他自己提供的方法，这段代码要对，本来就需要同步

5 楼 a123159521 2013-03-05  

di1984HIT 写道

这个内部put和get是原子的，就是说肯定不会出现内部数据结构错误吧。

至于put和get的对象，这个状态的变化的同步可能还是需要我们自己来做。

是的

4 楼 di1984HIT 2013-03-05  

这个内部put和get是原子的，就是说肯定不会出现内部数据结构错误吧。

至于put和get的对象，这个状态的变化的同步可能还是需要我们自己来做。

3 楼 a123159521 2012-08-24  

@2楼

这是我随意草稿帖。你说的有理。

就像我的标题说的：ConcurrentHashMap内部是线程安全的，但是ConcurrentHashMap.put(xx,xx),与ConcurrentHashMap get(xx)，也就是

tt.set()
 int s1 = widgetCacheMap.get(1L).getStatus();  

这里是两步，如果是多线程的话，可能这里的s1的值，并不是你set()的值。可能是别的线程set的，也可能是别的线程change().所以s1的值不定的，如果在多线程开发，这里需要加个锁，就会是你预想的值.
如下

synchronized ("") {
	                 tt.set();  
	                 s1 = widgetCacheMap.get(1L).getStatus();  
	        		}

2 楼 xinyiwust 2012-08-21  

今天无意中看到你这篇博客，我觉得有问题：
    1.widgetCacheMap = mm
你这样一来，widgetCacheMap指向了一个HashMap,它已经不是一个ConcurrentHashMap了；
    2.ConcurrentHashMap本身确实是一个线程安全的数据结构，但它的线程安全是有条件的，你的这个test方法：    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); 
                } 
        }
本身是有问题的，假如某一个线程刚执行完tt.set()中的 widgetCacheMap.put(1L,ss);然后另个线程立刻开始执行tt.change()中的 widgetCacheMap.put(1L,ss);并且执行完毕，那么第一个数就变成了2，同理第二个数也可能变成1.

1 楼 loveyfore 2012-02-28  

我也做了一下试验，貌似和你说的不太一致。。。旺旺我：五和