ConcurrentHashMap、synchronized与线程安全

最新推荐文章于 2024-09-14 01:59:58 发布
最新推荐文章于 2024-09-14 01:59:58 发布
阅读量312 收藏
点赞数
分类专栏： java

最近做的项目中遇到一个问题：明明用了ConcurrentHashMap，可是始终线程不安全

除去项目中的业务逻辑，简化后的代码如下：

[java]  view plain  copy
  1. public class Test40 {  
  2.   
  3.     public static void main(String[] args) throws InterruptedException {  
  4.         for (int i = 0; i < 10; i++) {  
  5.             System.out.println(test());  
  6.         }  
  7.     }  
  8.       
  9.     private static int test() throws InterruptedException {  
  10.         ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();  
  11.         ExecutorService pool = Executors.newCachedThreadPool();  
  12.         for (int i = 0; i < 8; i++) {  
  13.             pool.execute(new MyTask(map));  
  14.         }  
  15.         pool.shutdown();  
  16.         pool.awaitTermination(1, TimeUnit.DAYS);  
  17.           
  18.         return map.get(MyTask.KEY);  
  19.     }  
  20. }  
  21.   
  22. class MyTask implements Runnable {  
  23.       
  24.     public static final String KEY = "key";  
  25.       
  26.     private ConcurrentHashMap<String, Integer> map;  
  27.       
  28.     public MyTask(ConcurrentHashMap<String, Integer> map) {  
  29.         this.map = map;  
  30.     }  
  31.   
  32.     @Override  
  33.     public void run() {  
  34.         for (int i = 0; i < 100; i++) {  
  35.             this.addup();  
  36.         }  
  37.     }  
  38.       
  39.     private void addup() {  
  40.         if (!map.containsKey(KEY)) {  
  41.             map.put(KEY, 1);  
  42.         } else {  
  43.             map.put(KEY, map.get(KEY) + 1);  
  44.         }      
  45.     }  
  46. }  

测试代码跑了10次，每次都不是800。这就很让人疑惑了，难道ConcurrentHashMap的线程安全性失效了？

查了一些资料后发现，原来ConcurrentHashMap的线程安全指的是，它的每个方法单独调用（即原子操作）都是线程安全的，但是代码总体的互斥性并不受控制。以上面的代码为例，最后一行中的：

[java]  view plain  copy
  1. map.put(KEY, map.get(KEY) + 1);  

实际上并不是原子操作，它包含了三步：

  1. map.get
  2. 加1
  3. map.put

其中第1和第3步，单独来说都是线程安全的，由ConcurrentHashMap保证。但是由于在上面的代码中，map本身是一个共享变量。当线程A执行map.get的时候，其它线程可能正在执行map.put，这样一来当线程A执行到map.put的时候，线程A的值就已经是脏数据了，然后脏数据覆盖了真值，导致线程不安全

简单地说，ConcurrentHashMap的get方法获取到的是此时的真值，但它并不保证当你调用put方法的时候，当时获取到的值仍然是真值

为了使上面的代码变得线程安全，我引入了synchronized关键字来修饰目标方法，如下：

[java]  view plain  copy
  1. public class Test40 {  
  2.   
  3.     public static void main(String[] args) throws InterruptedException {  
  4.         for (int i = 0; i < 10; i++) {  
  5.             System.out.println(test());  
  6.         }  
  7.     }  
  8.       
  9.     private static int test() throws InterruptedException {  
  10.         ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();  
  11.         ExecutorService pool = Executors.newCachedThreadPool();  
  12.         for (int i = 0; i < 8; i++) {  
  13.             pool.execute(new MyTask(map));  
  14.         }  
  15.         pool.shutdown();  
  16.         pool.awaitTermination(1, TimeUnit.DAYS);  
  17.           
  18.         return map.get(MyTask.KEY);  
  19.     }  
  20. }  
  21.   
  22. class MyTask implements Runnable {  
  23.       
  24.     public static final String KEY = "key";  
  25.       
  26.     private ConcurrentHashMap<String, Integer> map;  
  27.       
  28.     public MyTask(ConcurrentHashMap<String, Integer> map) {  
  29.         this.map = map;  
  30.     }  
  31.   
  32.     @Override  
  33.     public void run() {  
  34.         for (int i = 0; i < 100; i++) {  
  35.             this.addup();  
  36.         }  
  37.     }  
  38.       
  39.     private synchronized void addup() { // 用关键字synchronized修饰addup方法  
  40.         if (!map.containsKey(KEY)) {  
  41.             map.put(KEY, 1);  
  42.         } else {  
  43.             map.put(KEY, map.get(KEY) + 1);  
  44.         }  
  45.     }  
  46.       
  47. }  

运行之后仍然是线程不安全的，难道synchronized也失效了？

查阅了synchronized的资料后，原来，不管synchronized是用来修饰方法，还是修饰代码块，其本质都是锁定某一个对象。修饰方法时，锁上的是调用这个方法的对象，即this；修饰代码块时，锁上的是括号里的那个对象

在上面的代码中，很明显就是锁定的MyTask对象本身。但是由于在每一个线程中，MyTask对象都是独立的，这就导致实际上每个线程都对自己的MyTask进行锁定，而并不会干涉其它线程的MyTask对象。换言之，上锁压根没有意义

理解到这点之后，对上面的代码又做了一次修改：

[java]  view plain  copy
  1. public class Test40 {  
  2.   
  3.     public static void main(String[] args) throws InterruptedException {  
  4.         for (int i = 0; i < 10; i++) {  
  5.             System.out.println(test());  
  6.         }  
  7.     }  
  8.       
  9.     private static int test() throws InterruptedException {  
  10.         ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();  
  11.         ExecutorService pool = Executors.newCachedThreadPool();  
  12.         for (int i = 0; i < 8; i++) {  
  13.             pool.execute(new MyTask(map));  
  14.         }  
  15.         pool.shutdown();  
  16.         pool.awaitTermination(1, TimeUnit.DAYS);  
  17.           
  18.         return map.get(MyTask.KEY);  
  19.     }  
  20. }  
  21.   
  22. class MyTask implements Runnable {  
  23.       
  24.     public static final String KEY = "key";  
  25.       
  26.     private ConcurrentHashMap<String, Integer> map;  
  27.       
  28.     public MyTask(ConcurrentHashMap<String, Integer> map) {  
  29.         this.map = map;  
  30.     }  
  31.   
  32.     @Override  
  33.     public void run() {  
  34.         for (int i = 0; i < 100; i++) {  
  35.             synchronized (map) { // 对共享对象map上锁  
  36.                 this.addup();  
  37.             }  
  38.         }  
  39.     }  
  40.       
  41.     private void addup() {  
  42.         if (!map.containsKey(KEY)) {  
  43.             map.put(KEY, 1);  
  44.         } else {  
  45.             map.put(KEY, map.get(KEY) + 1);  
  46.         }  
  47.     }  
  48.       
  49. }  

此时在调用addup时直接锁定map，由于map是被所有线程共享的，因而达到了让所有线程互斥的目的，线程安全达成。

修改后，ConcurrentHashMap的作用就不大了，可以直接将代码中的map换成普通的HashMap，以减少由ConcurrentHashMap带来的锁开销

最后特别补充的是，synchronized关键字判断对象是否是它属于锁定的对象，本质上是通过 == 运算符来判断的。换句话说，上面的代码中，可以采用任何一个常量，或者每个线程都共享的变量，或者MyTask类的静态变量，来代替map。只要该变量与synchronized锁定的目标变量相同（==），就可以使synchronized生效

综上，代码最终可以修改为：

[java]  view plain  copy
  1. public class Test40 {  
  2.   
  3.     public static void main(String[] args) throws InterruptedException {  
  4.         for (int i = 0; i < 100; i++) {  
  5.             System.out.println(test());  
  6.         }  
  7.     }  
  8.       
  9.     private static int test() throws InterruptedException {  
  10.         Map<String, Integer> map = new HashMap<String, Integer>();  
  11.         ExecutorService pool = Executors.newCachedThreadPool();  
  12.         for (int i = 0; i < 8; i++) {  
  13.             pool.execute(new MyTask(map));  
  14.         }  
  15.         pool.shutdown();  
  16.         pool.awaitTermination(1, TimeUnit.DAYS);  
  17.           
  18.         return map.get(MyTask.KEY);  
  19.     }  
  20. }  
  21.   
  22. class MyTask implements Runnable {  
  23.       
  24.     public static Object lock = new Object();  
  25.       
  26.     public static final String KEY = "key";  
  27.       
  28.     private Map<String, Integer> map;  
  29.       
  30.     public MyTask(Map<String, Integer> map) {  
  31.         this.map = map;  
  32.     }  
  33.   
  34.     @Override  
  35.     public void run() {  
  36.         for (int i = 0; i < 100; i++) {  
  37.             synchronized (lock) {  
  38.                 this.addup();  
  39.             }  
  40.         }  
  41.     }  
  42.       
  43.     private void addup() {  
  44.         if (!map.containsKey(KEY)) {  
  45.             map.put(KEY, 1);  
  46.         } else {  
  47.             map.put(KEY, map.get(KEY) + 1);  
  48.         }  
  49.     }  
  50.       
  51. }  
paullinjie
关注
专栏目录
ConcurrentHashMap是如何实现线程安全的
xuehuagongzi000的博客
11-05 236
多段锁+cas+synchronize。
ConcurrentHashMap使用Node+CAS+synchronized实现线程安全
weixin_44893585的博客
02-29 4217
官网对ConcurrentHashMap的使用场景的介绍 //{Hashtable} is synchronized. If a //thread-safe implementation is not needed, it is recommended to use //{HashMap} in place of {@code Hashtable}. If a thread-safe //hi...
CurrentHashMap的底层原理
最新发布
qq_62923382的博客
09-14 857
CurrentHashMap在jdk1.8之前使用的是分段锁，在jdk1.8中使用""来保证线程安全。
synchronized锁和ConcurrentHashMap
咕噜噜的博客
02-22 1442
synchronized锁的基本使用和ConcurrentHashMap的一些分析
并发容器ConcurrentHashMap与synchronized联合使用达到线程安全
11-13 915
换句话说，上面的代码中，可以采用任何一个常量，或者每个线程都共享的变量，或者MyTask类的静态变量，来代替map。当线程A执行map.get的时候，其它线程可能正在执行map.put，这样一来当线程A执行到map.put的时候，线程A的值就已经是脏数据了，然后脏数据覆盖了真值，导致线程不安全。修饰方法时，锁上的是调用这个方法的对象，即this；查了一些资料后发现，原来ConcurrentHashMap的线程安全指的是，它的每个方法单独调用（即原子操作）都是线程安全的，但是代码总体的互斥性并不受控制。
ConcurrentHashMap
weixin_47414034的博客
12-01 886
我们说ConcurrentHashMap是用在多并发环境下的HashMapJDK1.7segment数组+HashEntry数组+链表（即两个数组+挂一个链表）上锁的时候锁的是segment数组，采用分段锁，每一把锁只锁一个Segment，默认是这个数组大小为16，所以最多可以有16个线程进行并发操作segemnt数组中的元素下面对应的是HashEntry数组（这个数组是可以扩容的）JDK1.8的ConcurrentHashMap已经和HashMap的底层数据结构很相似了。
从源码看concurrentHashMap如何实现线程安全的
qq_43253123的博客
10-29 592
从JDK1.2起，就有了HashMap，正如前一篇文章所说，HashMap不是线程安全的，因此多线程操作时需要格外小心。 在JDK1.5中，伟大的Doug Lea给我们带来了concurrent包，从此Map也有安全的了。 推荐 Spring Boot/Cloud /Redis视频： Java 微服务实践 - Spring Boot Java 微服务实践 - Spring Cloud redis...
hashtable和concurrentHashmap如何实现线程安全？
早起一杯咖啡
08-05 2519
HashTable 1、底层：数组+链表实现，无论key还是value都不能为null，线程安全，实现线程安全的方式是在修改数据时锁住整个HashTable（方法上加了synchronized关键字修饰），效率低，后来针对这一缺点ConcurrentHashMap做了相关优化。 2、初始size为11，扩容：newsize = oldsize*2+1 3、计算index的方法：index = (hash & 0x7FFFFFFF) % tab.length HashMap 1、底层：数组+链表（jd
ConcurrentHashMap使用Synchronized来保证线程安全
07-08
ConcurrentHashMap是一种线程安全的哈希表实现，它内部采用了分段锁（Segment-based locking）的设计，每个桶都由一个独立的锁来控制。当需要对某个键值对进行操作（如读取、写入）时，会获取对应桶的锁，而不是整个...
synchronized锁和ConcurrentHashMap锁
qq_38978882的博客
06-17 245
synchronized锁和ConcurrentHashMap锁
Synchronized锁原理及 ConcurrentHashMap
buhuisuanfa的博客
01-13 2599
如果其他的线程很快的释放锁，那么我们的自旋锁是非常合适的，因为并没有阻塞等待，而且一直尝试获取锁，但是如果其他线程长时间占用锁，那么我们自旋是十分的浪费CPU资源的，大概率我们Synchronized在自旋过程中，内部有一个计数器来记录我们自旋了多少次，自旋达到一次的次数我们就会升级为重量级锁。我们过年在房间吃花生，会剥皮，但是垃圾桶在客厅，我们现在有两种方案，第一种，剥一个花生，就去客厅扔一下皮，第二种，我们先把皮放在卫生纸上，等积攒一部分再去客厅扔，我们扔皮这个操作就相当于加锁。
concurrentHashMap 到底采取了什么措施使得它比synchronized(HashMap)好
iteye_11584的博客
10-23 432
免锁容器背后的通用策略： 1使用Lock机制 而不是synchronized 2 对容器的修改可以与读取操作同时发生，只要读取者只能看到完成修改的结果即可。（volatile） 3 修改是在容器数据结构的某一部分的一个单独副本上执行的，这样就能避免锁住整个容器 Java Memory Model中，Memory分为两类， main memory和working memory，mai...
ConcurrentHashMap如何保证线程安全
Antz Uhl Kone
02-14 797
HashMap的put,get,size等方法都不是线程安全的，而HashTable虽然保证了线程安全，但却是用了效率极低的方法，在put,get,size等方法上加上了synchronized，这就导致所有的并发进程都要竞争同一把锁，一个线程在进行同步操作时，其他线程都需要等待。 为了保证集合的线程安全性，Jdk提供了同步包装器，比如说Collections.synchronizedM...
HashTable和ConcurrentHashMap线程安全保证机制（jdk1.7）
Allen的博客
04-25 418
HashTable的线程安全 HashTable集合使用synchronized关键字来保证线程安全，但如果线程竞争很激烈，即同时有多个线程访问同一个HashTable对象，HashTablede效率就会变得非常低下。因为HashTable中的同步方法是由synchronized关键字修饰的，作用的是对象，当一个线程访问HashTable的方法时，其他线程访问HashTable的同步方法时，其他线...
四、虚拟机字节码执行引擎
qq_32323239的博客
09-22 444
运行时栈帧结构 Java虚拟机以方法作为最基本的执行单元，“栈帧”（Stack Frame）则是用于支持虚拟机进行方法 调用和方法执行背后的数据结构，它也是虚拟机运行时数据区中的虚拟机栈（Virtual Machine Stack）[1]的栈元素。栈帧存储了方法的局部变量表、操作数栈、动态连接和方法返回地址等信息和一些额外的附加信息。 局部变量表 局部变量表（Local Variables Table）是一组变量值的存储空间，用于存放方法参数和方法内部定义 的局部变量。在Java程序被编译为.
Java并发Concurrent包——ConcurrentHashMap原理分析
在梅边的专栏
03-07 320
ConcurrentHashMap 和 HashMap 的底层实现都是 数组+链表或红黑树 构成的。 HashMap 的源码分析见：Java集合框架——HashMap源码分析ConcurrentHashMap 相比 HashMap 支持多线程下的操作。 而与 HashTable 相比，虽然 HashTable 也是线程安全的，但是其大量使用的是 synchronized 关键字，锁的粒度比较大，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值