`

Map 四种同步方式的性能比较

threadOO 
阅读更多

如果需要使 Map 线程安全，大致有这么四种方法：

1、使用 synchronized 关键字，这也是最原始的方法。代码如下

Java代码 复制代码
  1. synchronized(anObject)   
  2. {   
  3.     value = map.get(key);   
  4. }  
synchronized(anObject)
{
	value = map.get(key);
}



JDK1.2 提供了 Collections.synchronizedMap(originMap) 方法，同步方式其实和上面这段代码相同。

2、使用 JDK1.5 提供的锁（java.util.concurrent.locks.Lock）。代码如下

Java代码 复制代码
  1. lock.lock();   
  2. value = map.get(key);   
  3. lock.unlock();  
lock.lock();
value = map.get(key);
lock.unlock();



3、实际应用中，可能多数操作都是读操作，写操作较少。针对这种情况，可以使用 JDK1.5 提供的读写锁（java.util.concurrent.locks.ReadWriteLock）。代码如下

Java代码 复制代码
  1. rwlock.readLock().lock();   
  2. value = map.get(key);   
  3. rwlock.readLock().unlock();  
rwlock.readLock().lock();
value = map.get(key);
rwlock.readLock().unlock();



这样两个读操作可以同时进行，理论上效率会比方法 2 高。

4、使用 JDK1.5 提供的 java.util.concurrent.ConcurrentHashMap 类。该类将 Map 的存储空间分为若干块，每块拥有自己的锁，大大减少了多个线程争夺同一个锁的情况。代码如下

Java代码 复制代码
  1. value = map.get(key); //同步机制内置在 get 方法中  
value = map.get(key); //同步机制内置在 get 方法中




写了段测试代码，针对这四种方式进行测试，结果见附图。测试内容为 1 秒钟所有 get 方法调用次数的总和。为了比较，增加了未使用任何同步机制的情况（非安全！）。理论上，不同步应该最快。

我的 CPU 是双核的（Core 2 Duo E6300），因此太多线程也没啥意义，所以只列出了单线程、两个线程和五个线程的情况。更多线程时，CPU 利用率提高，但增加了线程调度的开销，测试结果与五个线程差不多。

从附图可以看出：

1、不同步确实最快，与预期一致。
2、四种同步方式中，ConcurrentHashMap 是最快的，接近不同步的情况。
3、synchronized 关键字非常慢，比使用锁慢了两个数量级。真是大跌眼镜，我很迷惑为什会 synchronized 慢到这个程度。
4、使用读写锁的读锁，比普通所稍慢。这个比较意外，可能硬件或测试代码没有发挥出读锁的全部功效。

结论：

1、如果 ConcurrentHashMap 够用，则使用 ConcurrentHashMap。
2、如果需自己实现同步，则使用 JDK1.5 提供的锁机制，避免使用 synchronized 关键字。



 

  • 描述: 多个线程每秒 Map.get 的执行次数之和
  • 大小: 28.8 KB
  • 测试代码。只图方便了，不大 OO，见笑。


    Java代码 复制代码
    1. import java.util.*;   
    2. import java.util.concurrent.*;   
    3. import java.util.concurrent.locks.*;   
    4.   
    5. public class MapTest   
    6. {   
    7.     public static final int THREAD_COUNT = 1;   
    8.     public static final int MAP_SIZE = 1000;   
    9.     public static final int EXECUTION_MILLES = 1000;   
    10.     public static final int[] KEYS = new int[100];    
    11.        
    12.     public static void main(String[] args) throws Exception   
    13.     {   
    14.         //初始化   
    15.         Random rand = new Random();   
    16.         for (int i = 0; i < KEYS.length; ++i)   
    17.         {   
    18.             KEYS[i] = rand.nextInt();   
    19.         }   
    20.                    
    21.         //创建线程   
    22.         long start = System.currentTimeMillis();   
    23.         Thread[] threads = new Thread[THREAD_COUNT];   
    24.         for (int i = 0; i < THREAD_COUNT; ++i)   
    25.         {   
    26.             //threads[i] = new UnsafeThread();   
    27.             //threads[i] = new SynchronizedThread();   
    28.             //threads[i] = new LockThread();   
    29.             //threads[i] = new ReadLockThread();   
    30.             threads[i] = new ConcurrentThread();   
    31.             threads[i].start();   
    32.         }   
    33.            
    34.         //等待其它线程执行若干时间   
    35.         Thread.sleep(EXECUTION_MILLES);   
    36.   
    37.         //统计 get 操作的次数   
    38.         long sum = 0;          
    39.         for (int i = 0; i < THREAD_COUNT; ++i)   
    40.         {   
    41.             sum += threads[i].getClass().getDeclaredField("count").getLong(threads[i]);   
    42.         }   
    43.         long millisCost = System.currentTimeMillis() - start;   
    44.         System.out.println(sum + "(" + (millisCost) + "ms)");   
    45.         System.exit(0);   
    46.     }   
    47.        
    48.     public static void fillMap(Map<Integer, Integer> map)   
    49.     {   
    50.         Random rand = new Random();   
    51.            
    52.         for (int i = 0; i < MAP_SIZE; ++i)   
    53.         {   
    54.             map.put(rand.nextInt(), rand.nextInt());   
    55.         }   
    56.     }   
    57. }   
    58.   
    59. class UnsafeThread extends Thread   
    60. {   
    61.     private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();    
    62.     public long count = 0;     
    63.        
    64.     static  
    65.     {   
    66.         MapTest.fillMap(map);   
    67.     }   
    68.        
    69.     public void run()   
    70.     {   
    71.         for (;;)   
    72.         {   
    73.             int index = (int)(count % MapTest.KEYS.length);   
    74.             map.get(MapTest.KEYS[index]);   
    75.             ++count;   
    76.         }   
    77.     }   
    78. }   
    79.   
    80. class SynchronizedThread extends Thread   
    81. {   
    82.     private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();    
    83.     public long count = 0;   
    84.        
    85.     static  
    86.     {   
    87.         MapTest.fillMap(map);   
    88.     }   
    89.        
    90.     public void run()   
    91.     {   
    92.         for (;;)   
    93.         {   
    94.             int index = (int)(count % MapTest.KEYS.length);   
    95.             synchronized(SynchronizedThread.class)   
    96.             {   
    97.                 map.get(MapTest.KEYS[index]);   
    98.             }   
    99.             ++count;   
    100.         }   
    101.     }   
    102. }   
    103.   
    104. class LockThread extends Thread   
    105. {   
    106.     private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();    
    107.     private static Lock lock = new ReentrantLock();   
    108.     public long count = 0;   
    109.        
    110.     static  
    111.     {   
    112.         MapTest.fillMap(map);   
    113.     }   
    114.        
    115.     public void run()   
    116.     {   
    117.         for (;;)   
    118.         {   
    119.             int index = (int)(count % MapTest.KEYS.length);   
    120.             lock.lock();   
    121.             map.get(MapTest.KEYS[index]);   
    122.             lock.unlock();   
    123.             ++count;   
    124.         }   
    125.     }   
    126. }   
    127.   
    128. class ReadLockThread extends Thread   
    129. {   
    130.     private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();    
    131.     private static Lock lock = new ReentrantReadWriteLock().readLock();   
    132.     public long count = 0;   
    133.        
    134.     static  
    135.     {   
    136.         MapTest.fillMap(map);   
    137.     }   
    138.        
    139.     public void run()   
    140.     {   
    141.         for (;;)   
    142.         {   
    143.             int index = (int)(count % MapTest.KEYS.length);   
    144.             lock.lock();   
    145.             map.get(MapTest.KEYS[index]);   
    146.             lock.unlock();   
    147.             ++count;   
    148.         }   
    149.     }   
    150. }   
    151.   
    152. class ConcurrentThread extends Thread   
    153. {   
    154.     private static Map<Integer, Integer> map = new ConcurrentHashMap<Integer, Integer>();      
    155.     public long count = 0;   
    156.        
    157.     static  
    158.     {   
    159.         MapTest.fillMap(map);   
    160.     }   
    161.        
    162.     public void run()   
    163.     {   
    164.         for (;;)   
    165.         {   
    166.             int index = (int)(count % MapTest.KEYS.length);   
    167.             map.get(MapTest.KEYS[index]);   
    168.             ++count;   
    169.         }   
    170.     }   
    171. }  
    import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;

public class MapTest
{
	public static final int THREAD_COUNT = 1;
	public static final int MAP_SIZE = 1000;
	public static final int EXECUTION_MILLES = 1000;
	public static final int[] KEYS = new int[100]; 
	
	public static void main(String[] args) throws Exception
	{
		//初始化
		Random rand = new Random();
		for (int i = 0; i < KEYS.length; ++i)
		{
			KEYS[i] = rand.nextInt();
		}
				
		//创建线程
		long start = System.currentTimeMillis();
		Thread[] threads = new Thread[THREAD_COUNT];
		for (int i = 0; i < THREAD_COUNT; ++i)
		{
			//threads[i] = new UnsafeThread();
			//threads[i] = new SynchronizedThread();
			//threads[i] = new LockThread();
			//threads[i] = new ReadLockThread();
			threads[i] = new ConcurrentThread();
			threads[i].start();
		}
		
		//等待其它线程执行若干时间
		Thread.sleep(EXECUTION_MILLES);

		//统计 get 操作的次数
		long sum = 0;		
		for (int i = 0; i < THREAD_COUNT; ++i)
		{
			sum += threads[i].getClass().getDeclaredField("count").getLong(threads[i]);
		}
		long millisCost = System.currentTimeMillis() - start;
		System.out.println(sum + "(" + (millisCost) + "ms)");
		System.exit(0);
	}
	
	public static void fillMap(Map<Integer, Integer> map)
	{
		Random rand = new Random();
		
		for (int i = 0; i < MAP_SIZE; ++i)
		{
			map.put(rand.nextInt(), rand.nextInt());
		}
	}
}

class UnsafeThread extends Thread
{
	private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();	
	public long count = 0;	
	
	static
	{
		MapTest.fillMap(map);
	}
	
	public void run()
	{
		for (;;)
		{
			int index = (int)(count % MapTest.KEYS.length);
			map.get(MapTest.KEYS[index]);
			++count;
		}
	}
}

class SynchronizedThread extends Thread
{
	private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();	
	public long count = 0;
	
	static
	{
		MapTest.fillMap(map);
	}
	
	public void run()
	{
		for (;;)
		{
			int index = (int)(count % MapTest.KEYS.length);
			synchronized(SynchronizedThread.class)
			{
				map.get(MapTest.KEYS[index]);
			}
			++count;
		}
	}
}

class LockThread extends Thread
{
	private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();	
	private static Lock lock = new ReentrantLock();
	public long count = 0;
	
	static
	{
		MapTest.fillMap(map);
	}
	
	public void run()
	{
		for (;;)
		{
			int index = (int)(count % MapTest.KEYS.length);
			lock.lock();
			map.get(MapTest.KEYS[index]);
			lock.unlock();
			++count;
		}
	}
}

class ReadLockThread extends Thread
{
	private static Map<Integer, Integer> map = new HashMap<Integer, Integer>();	
	private static Lock lock = new ReentrantReadWriteLock().readLock();
	public long count = 0;
	
	static
	{
		MapTest.fillMap(map);
	}
	
	public void run()
	{
		for (;;)
		{
			int index = (int)(count % MapTest.KEYS.length);
			lock.lock();
			map.get(MapTest.KEYS[index]);
			lock.unlock();
			++count;
		}
	}
}

class ConcurrentThread extends Thread
{
	private static Map<Integer, Integer> map = new ConcurrentHashMap<Integer, Integer>();	
	public long count = 0;
	
	static
	{
		MapTest.fillMap(map);
	}
	
	public void run()
	{
		for (;;)
		{
			int index = (int)(count % MapTest.KEYS.length);
			map.get(MapTest.KEYS[index]);
			++count;
		}
	}
}
    • 大小: 28.8 KB
    分享到：
    | ConcurrentHashMap之实现细节
    评论
    1 楼 nishizhutou 2009-12-06  
    谢谢,那我就直接用ConcurrentHashMap了.
    另外,对于map,什么情况下需要同步?如果我确认不同线程使用的是Map里不同的对象,应该不用同步吧?
    本来我是想研究这个的,现在一看ConcurrentHashMap的性能这么好,干脆用它好了,还更保险, 
    发表评论

    您还没有登录,请您登录后再发表评论

    相关推荐

      4.5kW48槽8极永磁同步电机电磁性能及其热分析 文件包含各种性能波形，磁密云图，温度曲线，效率Map图，谐波分析等

      4.5kW48槽8极永磁同步电机电磁性能及其热分析 文件包含各种性能波形，磁密云图，温度曲线，效率Map图，谐波分析等

      MAP译码算法的研究

      map算法MAP算法在Turbo码译码中的实现及性能在数域中，串行级联的MAP算法是用于获得高性能的Turbo码译码器。一般情况下，解码器通过可编程门...随着Turbo码解码器同步技术的实现，提出了一种高效连续的MAP译码算法。

      电动汽车用永磁同步电机设计方法及相关问题的研究_吴世华.caj

      电动汽车驱动电机不仅关注传统的额定性能，更重视峰值性能、区域性能 等特殊指标。本文针对电动汽车的特殊要求，建立了一套电动汽车用永磁同步 电机设计方法。方法包括六个部分，分别是： (1) 主要尺寸设计。 (2) ...

      论文研究-双层多媒体动态同步模型构建方法研究.pdf

      研究分级移动IPv6协议中移动节点的移动性能和数据通信情况对移动锚点（MAP）选择机制的影响，将MAP按覆盖范围分成不同等级，提出了一种通过计算移动节点的移动性能和数据通信量，使移动节点按照移动性能的升降和通信...

      程序员刷题哪个好-concurrent_map:GO中性能更好的线程安全映射

      另一种是使用sync.map，它已从v.1.9 开始添加到同步包中。 不幸的是，sync.map 不能适用于所有情况，尤其是多线程写入的情况。 有关更多信息，请查看精彩视频。 这个项目是提供一个线程安全的映射，它是 Java ...

      Java理论与实践：并发集合类

      Hashtable提供了一种易于使用的、线程安全的、关联的map功能，这当然也是方便的。然而，线程安全性是凭代价换来的―― Hashtable的所有方法都是同步的。此时，无竞争的同步会导致可观的性能代价。Hashtable的后继者...

      java程序员面试题

      HashMap和Hashtable的区别。 HashMap是Hashtable的轻量级实现（非...Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。 同步和异步有何异同，在什么情况下分别使用他们？举例说明。

      java面试宝典

      181、四种会话跟踪技术 42 182、Request对象的主要方法 43 183、我们在web应用开发过程中经常遇到输出某种编码的字符，如iso8859-1等，如何输出一个某种编码的字符串？ 43 184、Servlet执行时一般实现哪几个方法？ ...

      性能超越Redis的NoSQL数据库SSDB.zip

      SSDB 是一个 C/C 语言开发的高性能 NoSQL 数据库, 支持 zset(sorted set), map(hash), kv, list 等数据结构, 用来替代或者与 Redis 配合存储十亿级别列表的数据. SSDB 在 QIHU 360 被大量使用, 同时也被国内外业界...

      TDS-OFDM系统高效并行MAP定时恢复算法

      针对 5G 通信无线多媒体传输时域同步—正交频分复用（TDS-OFDM）系统中的符号定时恢复处理慢、性能距离理论界较大等问题，提出了一种并行MAP定时恢复算法。它通过拉格朗日插值，能较好地提取最佳采样点幅度与极性...

      北邮通原资料（期末试题）

      北邮通信原理的相关资料主要是期末试题 北京邮电大学2006——2007 学年第I 学期 《通信原理》期末考试试题(A 卷) ...9. 格雷码是数字调制中经常采用的编码方式，对四进制调制来说，按照格雷码来 编码

      java中HashMap详解

      HashMap是Java中非常常用的一种数据结构，它实现了Map接口，用于存储键值对。HashMap内部使用哈希表来实现，通过将键映射到哈希表中的一个位置来快速查找和插入元素。 HashMap的主要特点是： 非线程安全：如果多个...

      论文研究-Hadoop海量数据迁移系统开发及应用.pdf

      从高能物理数据同步、归档等需求出发，设计和实现了一个通用的海量数据迁移系统，通过扩展HDFS数据访问方式，使用Map-Reduce直接在HDFS数据节点和其他存储系统/介质之间迁移数据。此外，系统设计实现了动态优先级...

      java面试笔试题大汇总.doc

      最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须为之提供外同步。 Hashtable和HashMap采用的hash/rehash算法都大概...

      125条常见的java面试笔试题大汇总

      HashMap和Hashtable的区别。 HashMap是Hashtable的轻量级实现（非线程安全的实现） ...现同步，而HashMap 就必须为之提供外同步。 Hashtable和HashMap采用的hash/rehash算法都大概一样，所 以性能不会有很大的差异。

      Java并发编程实战

      5.2.2　额外的原子Map操作 5.2.3　CopyOnWriteArrayList 5.3　阻塞队列和生产者-消费者模式 5.3.1　示例：桌面搜索 5.3.2　串行线程封闭 5.3.3　双端队列与工作密取 5.4　阻塞方法与中断方法 5.5　同步工具类 5.5.1...

      Java八股文的面试题

      Java集合框架（JCF）: Java集合框架提供了一套性能优化的接口和类，用于存储和处理数据集合，如List、Set、Map等。 多线程和并发: Java支持多线程编程，允许同时执行多个任务。Java中的并发编程机制包括线程、同步、...

      Java 并发编程实战

      5.2.2　额外的原子Map操作 5.2.3　CopyOnWriteArrayList 5.3　阻塞队列和生产者-消费者模式 5.3.1　示例：桌面搜索 5.3.2　串行线程封闭 5.3.3　双端队列与工作密取 5.4　阻塞方法与中断方法 5.5　同步工具类 5.5.1...

      enmap:具有其他实用程序方法的增强的Map结构

      增强地图是一种数据结构，可用于将数据存储在内存中，也可以将其保存在后台的数据库中。 这些操作快速，安全且无痛。 数据自动，无缝和异步地同步到数据库，以实现最大的有效性。 使用的存储系统是一个sqlite...

    Magicbox
    Global site tag (gtag.js) - Google Analytics