请选择 进入手机版 | 继续访问电脑版
设为首页收藏本站

猿媛之家

 找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
热搜: 活动 交友 discuz
查看: 3216|回复: 0

(Java)ConcurrentHashMap、synchronized与线程安全

[复制链接]

44

主题

48

帖子

198

积分

注册会员

Rank: 2

积分
198
发表于 2016-3-10 16:54:56 | 显示全部楼层 |阅读模式

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

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


  1. public class Test40 {
  2.     public static void main(String[] args) throws InterruptedException {
  3.         for (int i = 0; i < 10; i++) {
  4.             System.out.println(test());
  5.         }
  6.     }
  7.    
  8.     private static int test() throws InterruptedException {
  9.         ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();
  10.         ExecutorService pool = Executors.newCachedThreadPool();
  11.         for (int i = 0; i < 8; i++) {
  12.             pool.execute(new MyTask(map));
  13.         }
  14.         pool.shutdown();
  15.         pool.awaitTermination(1, TimeUnit.DAYS);
  16.         
  17.         return map.get(MyTask.KEY);
  18.     }
  19. }

  20. class MyTask implements Runnable {
  21.    
  22.     public static final String KEY = "key";
  23.    
  24.     private ConcurrentHashMap<String, Integer> map;
  25.    
  26.     public MyTask(ConcurrentHashMap<String, Integer> map) {
  27.         this.map = map;
  28.     }

  29.     @Override
  30.     public void run() {
  31.         for (int i = 0; i < 100; i++) {
  32.             this.addup();
  33.         }
  34.     }
  35.    
  36.     private void addup() {
  37.         if (!map.containsKey(KEY)) {
  38.             map.put(KEY, 1);
  39.         } else {
  40.             map.put(KEY, map.get(KEY) + 1);
  41.         }   
  42.     }
  43. }
复制代码

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

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


map.put(KEY, map.get(KEY) + 1);
实际上并不是原子操作,它包含了三步:

  • map.get
  • 加1
  • map.put

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

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

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


  1. public class Test40 {
  2.     public static void main(String[] args) throws InterruptedException {
  3.         for (int i = 0; i < 10; i++) {
  4.             System.out.println(test());
  5.         }
  6.     }
  7.    
  8.     private static int test() throws InterruptedException {
  9.         ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();
  10.         ExecutorService pool = Executors.newCachedThreadPool();
  11.         for (int i = 0; i < 8; i++) {
  12.             pool.execute(new MyTask(map));
  13.         }
  14.         pool.shutdown();
  15.         pool.awaitTermination(1, TimeUnit.DAYS);
  16.         
  17.         return map.get(MyTask.KEY);
  18.     }
  19. }

  20. class MyTask implements Runnable {
  21.    
  22.     public static final String KEY = "key";
  23.    
  24.     private ConcurrentHashMap<String, Integer> map;
  25.    
  26.     public MyTask(ConcurrentHashMap<String, Integer> map) {
  27.         this.map = map;
  28.     }

  29.     @Override
  30.     public void run() {
  31.         for (int i = 0; i < 100; i++) {
  32.             this.addup();
  33.         }
  34.     }
  35.    
  36.     private synchronized void addup() { // 用关键字synchronized修饰addup方法
  37.         if (!map.containsKey(KEY)) {
  38.             map.put(KEY, 1);
  39.         } else {
  40.             map.put(KEY, map.get(KEY) + 1);
  41.         }
  42.     }
  43.    
  44. }
复制代码

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

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

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

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


  1. public class Test40 {

  2.     public static void main(String[] args) throws InterruptedException {
  3.         for (int i = 0; i < 10; i++) {
  4.             System.out.println(test());
  5.         }
  6.     }
  7.    
  8.     private static int test() throws InterruptedException {
  9.         ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();
  10.         ExecutorService pool = Executors.newCachedThreadPool();
  11.         for (int i = 0; i < 8; i++) {
  12.             pool.execute(new MyTask(map));
  13.         }
  14.         pool.shutdown();
  15.         pool.awaitTermination(1, TimeUnit.DAYS);
  16.         
  17.         return map.get(MyTask.KEY);
  18.     }
  19. }

  20. class MyTask implements Runnable {
  21.    
  22.     public static final String KEY = "key";
  23.    
  24.     private ConcurrentHashMap<String, Integer> map;
  25.    
  26.     public MyTask(ConcurrentHashMap<String, Integer> map) {
  27.         this.map = map;
  28.     }

  29.     @Override
  30.     public void run() {
  31.         for (int i = 0; i < 100; i++) {
  32.             synchronized (map) { // 对共享对象map上锁
  33.                 this.addup();
  34.             }
  35.         }
  36.     }
  37.    
  38.     private void addup() {
  39.         if (!map.containsKey(KEY)) {
  40.             map.put(KEY, 1);
  41.         } else {
  42.             map.put(KEY, map.get(KEY) + 1);
  43.         }
  44.     }
  45.    
  46. }
复制代码

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

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

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

综上,代码最终可以修改为:


  1. public class Test40 {

  2.     public static void main(String[] args) throws InterruptedException {
  3.         for (int i = 0; i < 100; i++) {
  4.             System.out.println(test());
  5.         }
  6.     }
  7.    
  8.     private static int test() throws InterruptedException {
  9.         Map<String, Integer> map = new HashMap<String, Integer>();
  10.         ExecutorService pool = Executors.newCachedThreadPool();
  11.         for (int i = 0; i < 8; i++) {
  12.             pool.execute(new MyTask(map));
  13.         }
  14.         pool.shutdown();
  15.         pool.awaitTermination(1, TimeUnit.DAYS);
  16.         
  17.         return map.get(MyTask.KEY);
  18.     }
  19. }

  20. class MyTask implements Runnable {
  21.    
  22.     public static Object lock = new Object();
  23.    
  24.     public static final String KEY = "key";
  25.    
  26.     private Map<String, Integer> map;
  27.    
  28.     public MyTask(Map<String, Integer> map) {
  29.         this.map = map;
  30.     }

  31.     @Override
  32.     public void run() {
  33.         for (int i = 0; i < 100; i++) {
  34.             synchronized (lock) {
  35.                 this.addup();
  36.             }
  37.         }
  38.     }
  39.    
  40.     private void addup() {
  41.         if (!map.containsKey(KEY)) {
  42.             map.put(KEY, 1);
  43.         } else {
  44.             map.put(KEY, map.get(KEY) + 1);
  45.         }
  46.     }
  47.    
  48. }
复制代码
转自 http://blog.csdn.net/sadfishsc/article/details/42394955
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|Archiver|手机版|小黑屋|猿媛之家    

GMT+8, 2020-2-28 14:15 , Processed in 0.206747 second(s), 27 queries .

Powered by Discuz! X3.2

© 2001-2013 Comsenz Inc.

快速回复 返回顶部 返回列表