Java并发编程实战
王宝令
资深架构师
立即订阅
15049 人已学习
课程目录
已完结 50 讲
0/4登录后,你可以任选4讲全文学习。
开篇词 (1讲)
开篇词 | 你为什么需要学习并发编程?
免费
学习攻略 (1讲)
学习攻略 | 如何才能学好并发编程?
第一部分:并发理论基础 (13讲)
01 | 可见性、原子性和有序性问题:并发编程Bug的源头
02 | Java内存模型:看Java如何解决可见性和有序性问题
03 | 互斥锁(上):解决原子性问题
04 | 互斥锁(下):如何用一把锁保护多个资源?
05 | 一不小心就死锁了,怎么办?
06 | 用“等待-通知”机制优化循环等待
07 | 安全性、活跃性以及性能问题
08 | 管程:并发编程的万能钥匙
09 | Java线程(上):Java线程的生命周期
10 | Java线程(中):创建多少线程才是合适的?
11 | Java线程(下):为什么局部变量是线程安全的?
12 | 如何用面向对象思想写好并发程序?
13 | 理论基础模块热点问题答疑
第二部分:并发工具类 (14讲)
14 | Lock和Condition(上):隐藏在并发包中的管程
15 | Lock和Condition(下):Dubbo如何用管程实现异步转同步?
16 | Semaphore:如何快速实现一个限流器?
17 | ReadWriteLock:如何快速实现一个完备的缓存?
18 | StampedLock:有没有比读写锁更快的锁?
19 | CountDownLatch和CyclicBarrier:如何让多线程步调一致?
20 | 并发容器:都有哪些“坑”需要我们填?
21 | 原子类:无锁工具类的典范
22 | Executor与线程池:如何创建正确的线程池?
23 | Future:如何用多线程实现最优的“烧水泡茶”程序?
24 | CompletableFuture:异步编程没那么难
25 | CompletionService:如何批量执行异步任务?
26 | Fork/Join:单机版的MapReduce
27 | 并发工具类模块热点问题答疑
第三部分:并发设计模式 (10讲)
28 | Immutability模式:如何利用不变性解决并发问题?
29 | Copy-on-Write模式:不是延时策略的COW
30 | 线程本地存储模式:没有共享,就没有伤害
31 | Guarded Suspension模式:等待唤醒机制的规范实现
32 | Balking模式:再谈线程安全的单例模式
33 | Thread-Per-Message模式:最简单实用的分工方法
34 | Worker Thread模式:如何避免重复创建线程?
35 | 两阶段终止模式:如何优雅地终止线程?
36 | 生产者-消费者模式:用流水线思想提高效率
37 | 设计模式模块热点问题答疑
第四部分:案例分析 (4讲)
38 | 案例分析(一):高性能限流器Guava RateLimiter
39 | 案例分析(二):高性能网络应用框架Netty
40 | 案例分析(三):高性能队列Disruptor
41 | 案例分析(四):高性能数据库连接池HiKariCP
第五部分:其他并发模型 (4讲)
42 | Actor模型:面向对象原生的并发模型
43 | 软件事务内存:借鉴数据库的并发经验
44 | 协程:更轻量级的线程
45 | CSP模型:Golang的主力队员
结束语 (1讲)
结束语 | 十年之后,初心依旧
用户故事 (2讲)
用户来信 | 真好,面试考到这些并发编程,我都答对了!
3 个用户来信 | 打开一个新的并发世界
Java并发编程实战
登录|注册

01 | 可见性、原子性和有序性问题:并发编程Bug的源头

王宝令 2019-02-28
如果你细心观察的话,你会发现,不管是哪一门编程语言,并发类的知识都是在高级篇里。换句话说,这块知识点其实对于程序员来说,是比较进阶的知识。我自己这么多年学习过来,也确实觉得并发是比较难的,因为它会涉及到很多的底层知识,比如若你对操作系统相关的知识一无所知的话,那去理解一些原理就会费些力气。这是我们整个专栏的第一篇文章,我说这些话的意思是如果你在中间遇到自己没想通的问题,可以去查阅资料,也可以在评论区找我,以保证你能够跟上学习进度。
你我都知道,编写正确的并发程序是一件极困难的事情,并发程序的 Bug 往往会诡异地出现,然后又诡异地消失,很难重现,也很难追踪,很多时候都让人很抓狂。但要快速而又精准地解决“并发”类的疑难杂症,你就要理解这件事情的本质,追本溯源,深入分析这些 Bug 的源头在哪里。
那为什么并发编程容易出问题呢?它是怎么出问题的?今天我们就重点聊聊这些 Bug 的源头。

并发程序幕后的故事

这些年,我们的 CPU、内存、I/O 设备都在不断迭代,不断朝着更快的方向努力。但是,在这个快速发展的过程中,有一个核心矛盾一直存在,就是这三者的速度差异。CPU 和内存的速度差异可以形象地描述为:CPU 是天上一天,内存是地上一年(假设 CPU 执行一条普通指令需要一天,那么 CPU 读写内存得等待一年的时间)。内存和 I/O 设备的速度差异就更大了,内存是天上一天,I/O 设备是地上十年。
取消
完成
0/1000字
划线
笔记
复制
© 版权归极客邦科技所有,未经许可不得传播售卖。 页面已增加防盗追踪,如有侵权极客邦将依法追究其法律责任。
该试读文章来自付费专栏《Java并发编程实战》,如需阅读全部文章,
请订阅文章所属专栏。
立即订阅
登录 后留言

精选留言(306)

  • Jialin
    对于双重锁的问题,我觉得任大鹏分析的蛮有道理,线程A进入第二个判空条件,进行初始化时,发生了时间片切换,即使没有释放锁,线程B刚要进入第一个判空条件时,发现条件不成立,直接返回instance引用,不用去获取锁。如果对instance进行volatile语义声明,就可以禁止指令重排序,避免该情况发生。
    对于有些同学对CPU缓存和内存的疑问,CPU缓存不存在于内存中的,它是一块比内存更小、读写速度更快的芯片,至于什么时候把数据从缓存写到内存,没有固定的时间,同样地,对于有volatile语义声明的变量,线程A执行完后会强制将值刷新到内存中,线程B进行相关操作时会强制重新把内存中的内容写入到自己的缓存,这就涉及到了volatile的写入屏障问题,当然也就是所谓happen-before问题。

    作者回复: 厉害厉害,比我回答的全面多了

    2019-02-28
    4
    298
  • coder
    long类型64位,所以在32位的机器上,对long类型的数据操作通常需要多条指令组合出来,无法保证原子性,所以并发的时候会出问题🌝🌝🌝

    作者回复: 正解

    2019-02-28
    158
  • 任大鹏
    对于阿根一世同学的那个疑问,我个人认为CPU时间片切换后,线程B刚好执行到第一次判断instance==null,此时不为空,不用进入synchronized里,就将还未初始化的instance返回了

    作者回复: 正解!感谢回复。

    2019-02-28
    3
    98
  • 阿根一世
    对于双重锁检查那个例子,我有一个疑问,A如果没有完成实例的初始化,锁应该不会释放的,B是拿不到锁的,怎么还会出问题呢?

    作者回复: 后面好多同学已经帮我作答了,教好学生,饿死师傅啊

    2019-02-28
    2
    82
  • 嘎嘎
    针对阿根一世的问题,问题其实出现在new Singleton()这里。
    这一行分对于CPU来讲,有3个指令:
    1.分配内存空间
    2.初始化对象
    3.instance引用指向内存空间
    正常执行顺序1-2-3
    但是CPU重排序后执行顺序可能为1-3-2,那么问题就来了
    步骤如下:
    1.A、B线程同时进入了第一个if判断
    2.A首先进入synchronized块,由于instance为null,所以它执行instance = new Singleton();
    3.然后线程A执行1-> JVM先画出了一些分配给Singleton实例的空白内存,并赋值给instance
    4.在还没有进行第三步(将instance引用指向内存空间)的时候,线程A离开了synchronized块
    5.线程B进入synchronized块,读取到了A线程返回的instance,此时这个instance并未进行物理地址指向,是一个空对象。
    有人说将对象设置成volatile,其实也不能完全解决问题。volatile只是保证可见性,并不保证原子性。

    现行的比较通用的做法就是采用静态内部类的方式来实现。
    public class MySingleton {

    //内部类
    private static class MySingletonHandler{
    private static MySingleton instance = new MySingleton();
    }

    private MySingleton(){}

    public static MySingleton getInstance() {
    return MySingletonHandler.instance;
    }
    }

    作者回复: 厉害,一看就是经验丰富

    2019-02-28
    14
    54
  • MARK
    刚看过《java并发实战》,又是看了个开始就看不下去了😂😂,希望订阅专栏可以跟老师和其他童鞋一起坚持学习并发编程😄😄

    思考题:在32位的机器上对long型变量进行加减操作存在并发隐患的说法是正确的。
    原因就是文章里的bug源头之二:线程切换带来的原子性问题。
    非volatile类型的long和double型变量是8字节64位的,32位机器读或写这个变量时得把人家咔嚓分成两个32位操作,可能一个线程读了某个值的高32位,低32位已经被另一个线程改了。所以官方推荐最好把long\double 变量声明为volatile或是同步加锁synchronize以避免并发问题。

    贴一段java文档的说明
    https://docs.oracle.com/javase/specs/jls/se8/html/jls-17.html#jls-17.7

    17.7. Non-Atomic Treatment of double and long

    For the purposes of the Java programming language memory model, a single write to a non-volatile long or double value is treated as two separate writes: one to each 32-bit half. This can result in a situation where a thread sees the first 32 bits of a 64-bit value from one write, and the second 32 bits from another write.

    Writes and reads of volatile long and double values are always atomic.

    Writes to and reads of references are always atomic, regardless of whether they are implemented as 32-bit or 64-bit values.

    Some implementations may find it convenient to divide a single write action on a 64-bit long or double value into two write actions on adjacent 32-bit values. For efficiency's sake, this behavior is implementation-specific; an implementation of the Java Virtual Machine is free to perform writes to long and double values atomically or in two parts.

    Implementations of the Java Virtual Machine are encouraged to avoid splitting 64-bit values where possible. Programmers are encouraged to declare shared 64-bit values as volatile or synchronize their programs correctly to avoid possible complications.

    作者回复: 厉害厉害

    2019-02-28
    49
  • 别皱眉
    周末了
    对留言问题总结一下
     
    ------可见性问题------
    对于可见性那个例子我们先看下定义:
    可见性:一个线程对共享变量的修改,另外一个线程能够立刻看到
     
    并发问题往往都是综合证,这里即使是单核CPU,只要出现线程切换就会有原子性问题。但老师的目的是为了让大家明白什么是可见性
    或许我们可以把线程对变量的读可写都看作时原子操作,也就是cpu对变量的操作中间状态不可见,这样就能更加理解什么是可见性了。
     
    ------CPU缓存刷新到内存的时机------
    cpu将缓存写入内存的时机是不确定的。除非你调用cpu相关指令强刷
     
    ------双重锁问题------
    如果A线程与B线程如果同时进入第一个分支,那么这个程序就没有问题
     
    如果A线程先获取锁并出现指令重排序时,B线程未进入第一个分支,那么就可能出现空指针问题,这里说可能出现问题是因为当把内存地址赋值给共享变量后,CPU将数据写回缓存的时机是随机的
     
    ------ synchronized------
    线程在synchronized块中,发生线程切换,锁是不会释放的
     
    ------指令优化------
    除了编译优化,有一部分可以通过看汇编代码来看,但是CPU和解释器在运行期也会做一部分优化,所以很多时候都是看不到的,也很难重现。
     
    ------JMM模型和物理内存、缓存等关系------
    内存、cpu缓存是物理存在,jvm内存是软件存在的。
    关于线程的工作内存和寄存器、cpu缓存的关系 大家可以参考这篇文章
    https://blog.csdn.net/u013851082/article/details/70314778/
     
    ------IO操作------
    io操作不占用cpu,读文件,是设备驱动干的事,cpu只管发命令。发完命令,就可以干别的事情了。
     
     
    ------寄存器切换------ 
    寄存器是共用的,A线程切换到B线程的时候,寄存器会把操作A的相关内容会保存到内存里,切换回来的时候,会从内存把内容加载到寄存器。可以理解为每个线程有自己的寄存器
     
    请老师帮忙看看,有没问题。希望我的总结能帮到更多人😄😄

    作者回复: 没问题,总结的太到位了!!!

    2019-03-16
    3
    42
  • xx鼠
    Singleton instance改为volatile或者final就完美了,这里面其实涉及Java的happen-before原则。

    作者回复: 恭喜你,学会抢答了!

    2019-02-28
    2
    32
  • 落墨
    老师,运行文中的测试代码,有时会出现9000多的结果,不知道是什么原因?

    作者回复: 并发程序的诡异之处,就在于:我实在也想不通。

    2019-02-28
    2
    19
  • summer_Day
    我觉得阿根一世的问题应该是
    synchronized(Singleton.class) {
            if (instance == null)
              instance = new Singleton();
            }
    对于synchronized关键字已经对代码块进行加锁了
    我理解应该等价于
    synchronized(Singleton.class) {
            if (instance == null) {
              分配一块内存 M;
              将 M 的地址赋值给 instance 变量;
              最后在内存 M 上初始化 Singleton 对象。
            }
      }
     A如果没有完成实例的初始化,锁应该不会释放的,B是拿不到锁的,怎么还会出问题呢?
    2019-02-28
    2
    18
  • 我会得到
    零点一过刚好看到更新,果断一口气读完,带劲!可见性,原子性,有序性,操作系统作为基础,内存模型,机器指令,编译原理,一个都不能少,开始有点意思了👍

    作者回复: 后面讲内存模型,会更有意思。

    2019-02-28
    16
  • 冯治刚
    对于嘎嘎的回答:volatile只解决可见性问题,不保证原子性问题,这句话有点疑问。volatile禁止指令重排,所以instance得初始化过程不会重排,也就不会存在拿到空内存地址的instance。这不就间接地解决了这个NPE问题了吗?虽然不保证原子性,但起码不会出现问题。所以我认为加volatile是没问题的。
    2019-04-23
    12
  • 牧童纪年
    王老师,你文章中讲的 优化指令的执行次序 使得缓存能够更加合理的利用是什么意思?

    作者回复: 比如第1行:a=8
    第1000行:a=a*2;
    这个时候,把他们放到一起执行,是不是就能更好的利用缓存了?

    2019-02-28
    1
    11
  • 波波
    为老师点赞,讲了并发产生的前世今生,通俗易懂又不失深度。

    作者回复: 这么夸我,我真的会骄傲的

    2019-03-01
    9
  • 黄朋飞
    老师你好,请问文章中的缓存和内存什么区别,缓存不是在内存中存放着吗?

    作者回复: 对不起,是我没说清楚,这里的缓存,指的是CPU缓存。

    2019-02-28
    8
  • null
    看完文章来刷评论,看到阿根一世的童鞋问题,确实是这样,锁🔒都还没有释放,线程B根本获取不到对象,所以线程A创建的对象是完整的,线程B后续获取的对象也是初始化完成的对象。
    然后回去再看了一遍那一小段,当我看到线程B竞争锁资源失败后被阻塞,我就更肯定,应该是文章描述有误。
    当再往下看文章,发现后面有说:“一切都很完美,无懈可击”。soga,这是描述我们自己觉得正常的场景。
    接着文章下面分析异常的原因,但是没提到线程B在哪停下来,因此我们的思维还是停留在前面那一段,线程A和线程B都过了第一个判空语句,来了竞争锁 syncronized 这,所以有阿根一世同样的疑问。建议老师调整一下,在分析异常原因时,说明一下在哪个语句时发生了线程切换,这样童鞋们也更好理解。

    😂这理解有偏差,属于可见性问题,是我们大脑缓存了之前的描述,导致了异常的理解😂

    作者回复: 知音啊😂😂😂

    2019-03-31
    7
  • 小辉辉
    看完这一篇,觉得我之前看的《Java高并发编程详解》和《深入理解Java虚拟机》两本书没白看,至少看懂老师说的问题了,看完评论(差不多半小时),原来高手都在评论区😀 😀 😀
    2019-03-14
    7
  • 发条橙子 。
    老师 ,我有几个问题希望老师指点 ,也是涉及到操作系统的:

    1. 操作系统是以进程为单位共享资源 ,以线程单位进行调用 。 多个线程共享一个进程的资源 。 一个java应用占一个进程(jvm的内存模型的资源也在这个进程中) ,一个进程占一个cpu , 所以老师所说的多核cpu缓存,每个cpu有自己的缓存 ,AB两个线程在不同的cpu上操作不太理解 , 一个应用的AB两个线程是不是应该处在同个cpu上面 ???

    2. 如果按照老师所说不同线程在不同cpu上运行 , 是不是有个叫并行和并发的概念 。 单个cpu的时候多线程实际上是模拟并发的并行,实际上cpu只能一次执行一个线程,两个线程交替执行。 而到了多核中,可以真正的将两个线程AB同时分给cpu1 .cpu2同时执行,称之为并发??

    3. 我感觉老师第二点原子性中也有包含可见性问题,由于时间片到了, 当把资源读到自己的工作线程中时,由于不可见性,以为自己是最新的导致值不准确,这个也对应了第一个问题 , 两个线程是否在同个进程内共享资源

    问题有点多 , 可能自己的理解有偏差 ,希望老师指正

    作者回复: 进程和线程的关系,你可以看看操作系统原理。进程不占有CPU。操作系统会把CPU分配给线程。分到CPU的线程就能执行。
    并行,是同一时刻,两个线程都在执行。并发,是同一时刻,只有一个执行,但是一个时间段内,两个线程都执行了。

    2019-02-28
    7
  • rayjun
    第一个测试代码是不是有点问题,在静态方法中怎么能访问非静态变量呢?

    作者回复: 我本地测试的代码是下面这样的,为了说明问题,为了不占用篇幅,做了删减。final Test test = new Test();使用test访问的,所以可以访问

    public class Test {
        private int count = 0;
        private void add() {
            int idx = 0;
            while(idx++ < 10000000) {
                count += 1;
            }
        }
        public static int calc() throws Exception {
            final Test test = new Test();
            Thread th1 = new Thread(()->{
                test.add();
            });
            Thread th2 = new Thread(()->{
                test.add();
            });

            th1.start();
            th2.start();
            th1.join();
            th2.join();
            return test.count;
        }

        public static void main(String[] args) throws Exception {
            long c =calc();
            System.out.println(c);
        }
    }

    2019-03-03
    1
    6
  • cfreedomc
    今天主要学习了并发编程中三种类型的问题
    1.缓存导致的可见性问题
    2.线程切换导致的原子性问题
    3.编译优化带来的有序性问题
    也是让我认识到我们编程其实和医生看病一样,项目就是病人,当你给病人开药时,药的好处不必多说,更重要的是对于药的副作用有个清晰的认识才是一个好的医生

    最后从这节课后,遇到并发问题,我也可以系统的通过将问题分类到是以上哪种或者哪几种问题去解决问题

    如今天的课后题目,在java中 Long类型是64位的,在32位的系统中,Cpu指令要进行多次操作,无法保证原子性
    2019-02-28
    6
收起评论
99+
返回
顶部