ConcurrentHashMap、synchronized与线程安全

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

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

public class Test40 {

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println(test());
        }
    }

    private static int test() throws InterruptedException {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();
        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i < 8; i++) {
            pool.execute(new MyTask(map));
        }
        pool.shutdown();
        pool.awaitTermination(1, TimeUnit.DAYS);

        return map.get(MyTask.KEY);
    }
}

class MyTask implements Runnable {

    public static final String KEY = "key";

    private ConcurrentHashMap<String, Integer> map;

    public MyTask(ConcurrentHashMap<String, Integer> map) {
        this.map = map;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            this.addup();
        }
    }

    private void addup() {
        if (!map.containsKey(KEY)) {
            map.put(KEY, 1);
        } else {
            map.put(KEY, map.get(KEY) + 1);
        }
    }
}

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

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

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关键字来修饰目标方法，如下：

public class Test40 {

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println(test());
        }
    }

    private static int test() throws InterruptedException {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();
        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i < 8; i++) {
            pool.execute(new MyTask(map));
        }
        pool.shutdown();
        pool.awaitTermination(1, TimeUnit.DAYS);

        return map.get(MyTask.KEY);
    }
}

class MyTask implements Runnable {

    public static final String KEY = "key";

    private ConcurrentHashMap<String, Integer> map;

    public MyTask(ConcurrentHashMap<String, Integer> map) {
        this.map = map;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            this.addup();
        }
    }

    private synchronized void addup() { // 用关键字synchronized修饰addup方法
        if (!map.containsKey(KEY)) {
            map.put(KEY, 1);
        } else {
            map.put(KEY, map.get(KEY) + 1);
        }
    }

}

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

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

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

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

public class Test40 {

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println(test());
        }
    }

    private static int test() throws InterruptedException {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();
        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i < 8; i++) {
            pool.execute(new MyTask(map));
        }
        pool.shutdown();
        pool.awaitTermination(1, TimeUnit.DAYS);

        return map.get(MyTask.KEY);
    }
}

class MyTask implements Runnable {

    public static final String KEY = "key";

    private ConcurrentHashMap<String, Integer> map;

    public MyTask(ConcurrentHashMap<String, Integer> map) {
        this.map = map;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            synchronized (map) { // 对共享对象map上锁
                this.addup();
            }
        }
    }

    private void addup() {
        if (!map.containsKey(KEY)) {
            map.put(KEY, 1);
        } else {
            map.put(KEY, map.get(KEY) + 1);
        }
    }

}

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

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

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

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

public class Test40 {

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 100; i++) {
            System.out.println(test());
        }
    }

    private static int test() throws InterruptedException {
        Map<String, Integer> map = new HashMap<String, Integer>();
        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i < 8; i++) {
            pool.execute(new MyTask(map));
        }
        pool.shutdown();
        pool.awaitTermination(1, TimeUnit.DAYS);

        return map.get(MyTask.KEY);
    }
}

class MyTask implements Runnable {

    public static Object lock = new Object();

    public static final String KEY = "key";

    private Map<String, Integer> map;

    public MyTask(Map<String, Integer> map) {
        this.map = map;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            synchronized (lock) {
                this.addup();
            }
        }
    }

    private void addup() {
        if (!map.containsKey(KEY)) {
            map.put(KEY, 1);
        } else {
            map.put(KEY, map.get(KEY) + 1);
        }
    }

}
时间： 2024-10-13 21:22:20

ConcurrentHashMap、synchronized与线程安全的相关文章

Java多线程-同步:synchronized 和线程通信:生产者消费者模式

大家伙周末愉快,小乐又来给大家献上技术大餐.上次是说到了Java多线程的创建和状态|乐字节,接下来,我们再来接着说Java多线程-同步:synchronized 和线程通信:生产者消费者模式. 一.同步:synchronized 多个线程同时访问一个对象,可能造成非线程安全,数据可能错误,所谓同步:就是控制多个线程同时访就是控制多线程操作同一个对象时,注意是同一个对象,数据的准确性, 确保数据安全,但是加入同步后因为需要等待,所以效率相对低下. 如:一个苹果,自己一个人去咬怎么都不会出问题,但是

notify，wait，synchronized实现线程间通知

wait阻塞线程释放锁:notify使wait所在的线程被唤醒在次获得锁,并执行,但要等到notify所在的线程代码全部执行后! 示例代码如下: package com.vhbi.service.impl; import com.sun.org.apache.xerces.internal.xs.datatypes.ObjectList; import java.util.LinkedList; import java.util.List; import java.util.concurrent

Java 对象锁-synchronized()与线程的状态与生命周期

synchronized(someObject){ //对象锁 } 对象锁的使用说明: 1.对象锁的返还. 当synchronize()语句执行完成. 当synchronize()语句执行出现异常. 当线程调用了wait()方法. 2.使用对象锁保护的数据都必须是私有的. 3.对象锁具有可重入性. 一个线程在已经获得对象锁的情况下,可以再次请求获得对象锁. 4.线程的生命周期

synchronized之线程安全

一.当两个并发线程访问同一个对象object中的 这个synchronized(this)同步代码块时, 一个时间内只能有一个线程得到执行. 另一个线程必须等待当前线程执行完 这个代码块以后才能执行该代码块. @SuppressLint("SimpleDateFormat") public class MainActivity extends Activity implements OnClickListener{ private Thread mThraed; @Override p

多线程同步互斥实例——使用synchronized实现线程通信和互斥

线程互斥概念 线程互斥是指某一资源同时只允许一个访问者对其进行访问,具有唯一性和排它性.但互斥无法限制访问者对资源的访问顺序,即访问是无序的. 实现线程同步互斥的四种方式 临界区(Critical Section):适合一个进程内的多线程访问公共区域或代码段时使用 互斥量 (Mutex):适合不同进程内多线程访问公共区域或代码段时使用,与临界区相似. 事件(Event):通过线程间触发事件实现同步互斥 信号量(Semaphore):与临界区和互斥量不同,可以实现多个线程同时访问公共区域数据,原理

HashMap，Hashtable，ConcurrentHashMap 和 synchronized Map 的原理和区别

HashMap 是否是线程安全的,如何在线程安全的前提下使用 HashMap,其实也就是HashMap,Hashtable,ConcurrentHashMap 和 synchronized Map 的原理和区别.当时有些紧张只是简单说了下HashMap不是线程安全的:Hashtable 线程安全,但效率低,因为是 Hashtable 是使用 synchronized 的,所有线程竞争同一把锁:而 ConcurrentHashMap 不仅线程安全而且效率高,因为它包含一个 segment 数组,将

浅析HashMap与ConcurrentHashMap的线程安全性

本文要解决的问题: 最近无意中发现有很多对Map尤其是HashMap的线程安全性的话题讨论,在我的理解中,对HashMap的理解中也就知道它是线程不安全的,以及HashMap的底层算法采用了链地址法来解决哈希冲突的知识,但是对其线程安全性的认知有限,故写这篇博客的目的就是让和我一样对这块内容不熟悉的小伙伴有一个对HashMap更深的认知. 哈希表 在数据结构中有一种称为哈希表的数据结构,它实际上是数组的推广.如果有一个数组,要最有效的查找某个元素的位置,如果存储空间足够大,那么可以对每个元素和内

HashMap，Hashtable，ConcurrentHashMap和synchronized Map

HashMap: 线程不安全,链表结构,效率高: Hashtable : 线程安全,但效率低,因为是Hashtable是使用synchronized的,所有线程竞争同一把锁: Synchronized Map: 线程安全,但效率低,一次性锁住整张表来保证线程安全,所以每次只能有一个线程来访问map. ConcurrentHashMap:线程安全而且效率高,因为它包含一个segment数组,将数据分段存储,给每一段数据配一把锁. 在理想状态下,ConcurrentHashMap 可支持16个线程执

Java多线程:线程同步与关键字synchronized

一.同步的特性1. 不必同步类中所有的方法, 类可以同时拥有同步和非同步方法.2. 如果线程拥有同步和非同步方法, 则非同步方法可以被多个线程自由访问而不受锁的限制. 参见实验1:http://blog.csdn.net/huang_xw/article/details/73185613. 如果两个线程要执行一个类中的同步方法, 并且两个线程使用相同的实例来调用方法, 那么一次只能有一个线程能够执行方法, 另一个需要等待, 直到锁被释放. 参见实验2:http://blog.csdn.net/h