ConcurrentHashMap&&多线程

 众所周知hashMap　是线程不安全的，在多线程访问的情况下，要做同步的处理

ConcurrentHashMap是Java 5中支持高并发、高吞吐量的线程安全HashMap实现

 ConcurrentHashMap get()　总能拿到最新的值，类似于关键字　volatile保证100%读取到最新的数据

如下用代码说明：

 

package com.iteye.javaso.demo;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CopyOfConCurrentHashMapThreadTest2 {

	ConcurrentHashMap<String, String> map = new ConcurrentHashMap<String, String>();

	public static void main(String args[]) {
		CopyOfConCurrentHashMapThreadTest2 test = new CopyOfConCurrentHashMapThreadTest2();
		Runnable sleep = new ThreadSleep2(test, "第一条线程");

		ThreadSecond2 charge2 = new ThreadSecond2(test, "改变值的第2线程");
		ThreadSecond2 charge3 = new ThreadSecond2(test, "改变值的第3线程");
		ThreadSecond2 charge4 = new ThreadSecond2(test, "改变值的第4线程");

		ThreadSecond23 chargeXX = new ThreadSecond23(test, "改变值的XXXX线程");

		ExecutorService exc = Executors.newFixedThreadPool(5);

		exc.execute(sleep);

		exc.execute(charge3);
		exc.execute(charge2);
		exc.execute(chargeXX);
		exc.execute(charge4);
		exc.shutdown();
		System.out.println("洗洗睡吧－－－－－－－－－－－－－－－－");
		try {
			Thread.sleep(16000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("多个线程后，最终运行结果：" + test.map.get("firstKey"));
	}

	public  void put(String value, int state) {
		map.put("firstKey", value);

		// Thread thread= Thread.currentThread();
		if (state == 0) {
			System.out.println("开始睡觉了--------------");
			try {
				Thread.sleep(4000);
				System.out.println("睡醒了－－－－－－－");
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}

	}

}

class ThreadSleep2 extends Thread {

	ConcurrentHashMap<String, String> map;

	public ThreadSleep2(ConcurrentHashMap<String, String> map, String threadName) {

		this.map = map;
		this.name = threadName;
	}

	CopyOfConCurrentHashMapThreadTest2 test;

	public ThreadSleep2(CopyOfConCurrentHashMapThreadTest2 test,
			String threadName) {

		super(threadName);
		this.test = test;
		this.name = threadName;
	}

	@Override
	public void run() {
		Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
		System.out.println("---------------进入第一条线程-----睡十秒先--------");

		System.out.println("第一条线程未设置前值为：***　" + test.map.get("firstKey"));

		test.put(name, 0);

		System.out.println("第一条线程执行完毕  Map中值为：" +test.map.get("firstKey"));

	}

	String name = "";

	public String toString() {

		return "当前线程的名字是：" + name;
	}

}

class ThreadSecond2 extends Thread {

	ConcurrentHashMap<String, String> map;

	public ThreadSecond2(ConcurrentHashMap<String, String> map,
			String threadName) {
		super(threadName);
		this.map = map;
		this.name = threadName;
	}

	CopyOfConCurrentHashMapThreadTest2 test;

	public ThreadSecond2(CopyOfConCurrentHashMapThreadTest2 test,
			String threadName) {

		super(threadName);
		this.test = test;
		this.name = threadName;
	}

	@Override
	public void run() {
		System.out.println("-----------进入其它线程---------");
		System.out.println("当前线程是：" + this.name + " 未设置map前值为："
				+ test.map.get("firstKey"));

		test.put(name, 2);
		System.out.println("hashMap中 firstKey值为：" + name);
	}

	String name = "";

	public String toString() {

		return "当前线程的名字是：" + name;
	}

}

class ThreadSecond23 extends Thread {

	ConcurrentHashMap<String, String> map;

	public ThreadSecond23(ConcurrentHashMap<String, String> map,
			String threadName) {
		super(threadName);
		this.map = map;
		this.name = threadName;
	}

	CopyOfConCurrentHashMapThreadTest2 test;

	public ThreadSecond23(CopyOfConCurrentHashMapThreadTest2 test,
			String threadName) {

		super(threadName);
		this.test = test;
		this.name = threadName;
	}

	@Override
	public void run() {
		System.out.println("-----------进入XXXXXXX线程---------");
		System.out.println("当前线程是：" + Thread.currentThread().getName());
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		test.put(name, 2);
		System.out.println("hashMap中 firstKey值为：" + name);
	}

	String name = "";

	public String toString() {

		return "当前线程的名字是：" + name;
	}

}

 

---------------进入第一条线程-----睡十秒先--------
-----------进入其它线程---------
第一条线程未设置前值为：***　null
当前线程是：改变值的第2线程 未设置map前值为：null
hashMap中 firstKey值为：改变值的第2线程
洗洗睡吧－－－－－－－－－－－－－－－－
开始睡觉了--------------
-----------进入其它线程---------
-----------进入其它线程---------
当前线程是：改变值的第4线程 未设置map前值为：改变值的第2线程
-----------进入XXXXXXX线程---------
当前线程是：pool-1-thread-4
当前线程是：改变值的第3线程 未设置map前值为：改变值的第2线程
hashMap中 firstKey值为：改变值的第3线程
hashMap中 firstKey值为：改变值的第4线程
hashMap中 firstKey值为：改变值的XXXX线程
睡醒了－－－－－－－
第一条线程执行完毕  Map中值为：改变值的XXXX线程
多个线程后，最终运行结果：改变值的XXXX线程

 

最高优先级的线程：ThreadSleep2　 put 值后,进入睡眠，由于未进行同步处理，这时其它线程开始执行，改变了map中firstKey值，到最先执行的线程醒来后，输出map中firstKey值已被其它线程改变:改变值的XXXX线程, 可见get()　总能拿到最新的值，类似于关键字　volatile保证100%读取到最新的数据.

 

对put方法，进行同步后：

public synchronized  void put(String value, int state) {
		map.put("firstKey", value);

		// Thread thread= Thread.currentThread();
		if (state == 0) {
			System.out.println("开始睡觉了--------------");
			try {
				Thread.sleep(4000);
				System.out.println("睡醒了－－－－－－－");
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}

	}

 

		synchronized (test) {
			
		
		test.put(name, 0);

		System.out.println("第一条线程执行完毕  Map中值为：" +test.map.get("firstKey"));
		}

 

输出：

---------------进入第一条线程-----睡十秒先--------
第一条线程未设置前值为：***　null
开始睡觉了--------------
洗洗睡吧－－－－－－－－－－－－－－－－
-----------进入其它线程---------
-----------进入其它线程---------
当前线程是：改变值的第3线程 未设置map前值为：第一条线程
当前线程是：改变值的第2线程 未设置map前值为：第一条线程
-----------进入XXXXXXX线程---------
当前线程是：pool-1-thread-4
-----------进入其它线程---------
当前线程是：改变值的第4线程 未设置map前值为：第一条线程
睡醒了－－－－－－－
第一条线程执行完毕  Map中值为：第一条线程
hashMap中 firstKey值为：改变值的XXXX线程
hashMap中 firstKey值为：改变值的第2线程
hashMap中 firstKey值为：改变值的第3线程
hashMap中 firstKey值为：改变值的第4线程
多个线程后，最终运行结果：改变值的第3线程

 

 

其它线程要等待sleep线程释放锁，至第一条线程执行完毕时，map值为：sleep线程 put的值：第一条线程

 

结论ConcurrentHashMap put操作需要做同步，get操作不需要　　

 

 

 

 

 

 

 

 

评论

2 楼 javaso 2011-06-06  

Technoboy 写道

引用

结论ConcurrentHashMap put操作需要做同步，get操作不需要　

原因在于，ConcurrentHashMap中使用了锁分离技术，也就是说，它用多个锁来控制对hash表不同部分的修改操作。ConcurrentHashMap内部使用段(Segment)来表示这些不同的部分，每个段其实就是一个小的hash table，它们有自己的锁。只要多个修改操作发生在不同的段上，它们就可以并发进行，其也被定义为final，保证了数据的不变性。每当进行修改和删除的时候，首先判断是否在同一段内，只要不在同一段内，都可以进行并发的操作。

thanks

1 楼 Technoboy 2011-06-03  

引用

结论ConcurrentHashMap put操作需要做同步，get操作不需要　

原因在于，ConcurrentHashMap中使用了锁分离技术，也就是说，它用多个锁来控制对hash表不同部分的修改操作。ConcurrentHashMap内部使用段(Segment)来表示这些不同的部分，每个段其实就是一个小的hash table，它们有自己的锁。只要多个修改操作发生在不同的段上，它们就可以并发进行，其也被定义为final，保证了数据的不变性。每当进行修改和删除的时候，首先判断是否在同一段内，只要不在同一段内，都可以进行并发的操作。