关于ConcurrentHashMap同步的理解？

0 0

关于ConcurrentHashMap同步的理解？0

在网上看ConcurrentHashMap是线程安全的，我测试的结果却不是这样。

1.开启线程

public class MapRun {
	public static void main(String[] args) {
		
		for(int i = 0 ; i < 10 ; i ++){
			MapKey map = new MapKey();
			new Thread(map).start();
		}

	}
}

public class MapKey implements Runnable {

	
	private final static Map<String , Integer> map = new ConcurrentHashMap<String, Integer>();
	public void run() {
	
		int key = 0;
		if(map.get("taleName") == null){
		  map.put("taleName", 1);
		}
		else{
		    key = map.get("taleName");
			map.put("taleName", key+1);
		}
		System.out.println(map.get("taleName"));
	}
	

}

测试的结果还是有重复的

查了很多资料，这里的线程安全是不是说，ConcurrentHashMap只能存一个相同的变量？

ConcurrentHashMap

2014年7月09日 14:26

xchd
4
0 1 24

10个答案按时间排序按投票排序

0 0

ConcurrentHashMap,put是操作是加了锁的，可以保证是原子操作但是你下面的代码却不是原子操作：

 
        int key = 0;  
        if(map.get("taleName") == null){  
          map.put("taleName", 1);  
        }  
        else{  
            key = map.get("taleName");  
            map.put("taleName", key+1);  
        }  
        System.out.println(map.get("taleName"));

两个线程同时获取同一个value，假如说是10，这时A线程在执行其他线程在等待，
A线程将值修改为11，这时B线程开始执行，由于获取的值是10，所以这时B线程也会将值设为11，所以造成你所说的重复。
正确写法如下：
synchronized(map) {
   if(map.get("taleName") == null){
          map.put("taleName", 1);
        }
    ....
}

2014年7月14日 14:01

征途2010
30
0 1 3

添加评论

0 0

源码中get和put均lock()，即确保类是线程安全的。但由线程安全的类组成的新类却不一定是线程安全的，所以需要确定原子操作，对原子操作进行同步，这样才能保证新类是安全的。

2014年7月11日 18:21

直线曲线
25
0 0 4

2条评论

0 0

使用putIfAbsent()，不使用

if(map.get("taleName") == null){  
          map.put("taleName", 1);  
        }

完整代码

import java.util.concurrent.ConcurrentHashMap;
public class MapRun {
	public static void main(String[] args) {
		for(int i = 0 ; i < 10 ; i ++){
			MapKey map = new MapKey();
			new Thread(map).start();
		}
	}
}
class MapKey implements Runnable {
	private final static ConcurrentHashMap<String , Integer> map = new ConcurrentHashMap<String, Integer>();

	public void run() {
		map.putIfAbsent("taleName", 0);
		map.put("taleName", map.get("taleName") + 1);
		System.out.println(Thread.currentThread().getName() + "  " + map.get("taleName"));
	}
}

结果：

引用

Thread-0 1
Thread-1 2
Thread-2 3
Thread-3 4
Thread-5 5
Thread-7 6
Thread-9 7
Thread-6 8
Thread-8 9
Thread-4 10

2014年7月11日 11:37

xmind
197
0 0 2

1条评论

0 0

package org.vocano.java.tst.thread;

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

public class MapRun {
	public static void main(String[] args) {
		for(int i = 0 ; i < 10 ; i ++){
			MapKey map = new MapKey();
			new Thread(map).start();
		}
	}
}

class MapKey implements Runnable {
	
	private final static Map<String , Integer> map = new HashMap<String, Integer>();
//	private final static Map<String , Integer> map = new ConcurrentHashMap<String, Integer>();
	
	public void run() {
		int key = 0;
		synchronized (map) {
			if(map.get("taleName") == null){
				map.put("taleName", 1);
			} else {
				key = map.get("taleName");
				map.put("taleName", key+1);
			}
			System.out.println(Thread.currentThread().getName() + "  " + map.get("taleName"));
		}
	}
}

引用

Thread-0 1
Thread-3 2
Thread-2 3
Thread-5 4
Thread-7 5
Thread-4 6
Thread-9 7
Thread-6 8
Thread-8 9
Thread-1 10

题的本意应该是这个，不难理解。

不过这样的话HashMap和ConcurrentHashMap都能实现。

ConcurrentHashMap有什么特别的用处呢？

2014年7月10日 16:38

xmind
197
0 0 2

1条评论

0 0

线程安全的意思是，一个对象被N个线程同时操都不会坏（对象内部结构乱掉）。
比如HashMap，多个线程同时put时，会死循环的（其内部结构乱掉了）。
ConcurrentHashMap就不会。

2014年7月10日 13:56

james_lover
40
0 1 3

添加评论

0 0

http://www.baike.com/wiki/ConcurrentHashMap

ConcurrentHashMap的get操作是不加锁的，而put是加锁的，这是问题的根源

2014年7月10日 11:06

onlylau
618
1 2 47

添加评论

0 0

ConcurrentHashMap同步，只是指PUT,GET时会有锁，可看源码如put时会有sync.lock()。

这里多个线程跑的时候,MapKey里没有同步。前个线程还没来得及map.put(1)，后面就判断map.get()==null了，再一次map.put(1)

2014年7月10日 10:59

hotapple
8
0 0 6

添加评论

0 0

每个线程都创建一个ConcurrentHashMap对象，

2014年7月10日 09:38

zong.jianhui06
30
0 0 1

添加评论

0 0

你这个多线程程序创建了多个不同的ConcurrentHashMap对象，都没有同步产生，代码写的不对，应该是多个线程共用一个ConcurrentHashMap对象才对。

2014年7月09日 17:47

xiaohu7924
30
0 0 2

1条评论

0 0

不是ConcurrentHashMap不是线程安全，而是题主对线程安全的理解有问题：

一个类是线程安全的，指的是一次方法调用的范围，而不是多个方法调用。类似于题主的代码，实际上是需要再使用端加上相应的锁才能保证是线程安全的。

如

synchronized(map) {
   if(map.get("taleName") == null){
          map.put("taleName", 1);
        }
    ....
}

否则不能保证是线程安全的。

2014年7月09日 15:09

鳄鱼旭
248
0 0 17