请选择 进入手机版 | 继续访问电脑版
零一零零 门户 IT技术 Java并发 查看内容

并发编程三大核心问题

2020-6-18 15:50| 发布者: x0100| 查看: 855| 评论: 0

摘要: 写在前面 编写并发程序是比较困难的,因为并发程序极易出现Bug,这些Bug有都是比较诡异的,很多都是没办法追踪,而且难以复现。 要快速准确的发现并解决这些问题,首先就是要弄清并发编程的本质,并发编程要解决的是 ...

 

写在前面

编写并发程序是比较困难的,因为并发程序极易出现Bug,这些Bug有都是比较诡异的,很多都是没办法追踪,而且难以复现。

要快速准确的发现并解决这些问题,首先就是要弄清并发编程的本质,并发编程要解决的是什么问题。

本文将带你深入理解并发编程要解决的三大问题:原子性、可见性、有序性。

补充知识

硬件的发展中,一直存在一个矛盾,CPU、内存、I/O设备的速度差异。

速度排序:CPU >> 内存 >> I/O设备

为了平衡这三者的速度差异,做了如下优化:

  1. CPU 增加了缓存,以均衡内存与CPU的速度差异;

  2. 操作系统增加了进程、线程,以分时复用CPU,进而均衡I/O设备与CPU的速度差异;

  3. 编译程序优化指令执行次序,使得缓存能够得到更加合理地利用。

可见性

可见性是什么?

一个线程对共享变量的修改,另外一个线程能够立刻看到,我们称为可见性。

为什么会有可见性问题?

对于如今的多核处理器,每颗CPU都有自己的缓存,而缓存仅仅对它所在的处理器可见,CPU缓存与内存的数据不容易保证一致。

为了避免处理器停顿下来等待向内存写入数据而产生的延迟,处理器使用写缓冲区来临时保存向内存写入的数据。写缓冲区合并对同一内存地址的多次写,并以批处理的方式刷新,也就是说写缓冲区不会即时将数据刷新到主内存中

缓存不能及时刷新导致了可见性问题。

可见性问题举例

  1. public class Test {
  2. public int a = 0;
  3. public void increase() {
  4. a++;
  5. }
  6. public static void main(String[] args) {
  7. final Test test = new Test();
  8. for (int i = 0; i < 10; i++) {
  9. new Thread() {
  10. public void run() {
  11. for (int j = 0; j < 1000; j++)
  12. test.increase();
  13. };
  14. }.start();
  15. }
  16. while (Thread.activeCount() > 1) {
  17. // 保证前面的线程都执行完
  18. Thread.yield();
  19. }
  20. System.out.println(test.a);
  21. }
  22. }

目的:10个线程将inc加到10000。

结果:每次运行,得到的结果都小于10000。

原因分析:

假设线程1和线程2同时开始执行,那么第一次都会将a=0 读到各自的CPU缓存里,线程1执行a++之后a=1,但是此时线程2是看不到线程1中a的值的,所以线程2里a=0,执行a++后a=1。

线程1和线程2各自CPU缓存里的值都是1,之后线程1和线程2都会将自己缓存中的a=1写入内存,导致内存中a=1,而不是我们期望的2。所以导致最终 a 的值都是小于 10000 的。这就是缓存的可见性问题。

原子性

原子性是什么?

把一个或者多个操作在 CPU 执行的过程中不被中断的特性称为原子性。

在并发编程中,原子性的定义不应该和事务中的原子性(一旦代码运行异常可以回滚)一样。应该理解为:一段代码,或者一个变量的操作,在一个线程没有执行完之前,不能被其他线程执行。

为什么会有原子性问题?

线程是CPU调度的基本单位。CPU会根据不同的调度算法进行线程调度,将时间片分派给线程。当一个线程获得时间片之后开始执行,在时间片耗尽之后,就会失去CPU使用权。多线程场景下,由于时间片在线程间轮换,就会发生原子性问题

如:对于一段代码,一个线程还没执行完这段代码但是时间片耗尽,在等待CPU分配时间片,此时其他线程可以获取执行这段代码的时间片来执行这段代码,导致多个线程同时执行同一段代码,也就是原子性问题。

线程切换带来原子性问题。

在Java中,对基本数据类型的变量的读取和赋值操作是原子性操作,即这些操作是不可被中断的,要么执行,要么不执行。

  1. i = 0; // 原子性操作
  2. j = i; // 不是原子性操作,包含了两个操作:读取i,将i值赋值给j
  3. i++; // 不是原子性操作,包含了三个操作:读取i值、i + 1 、将+1结果赋值给i
  4. i = j + 1; // 不是原子性操作,包含了三个操作:读取j值、j + 1 、将+1结果赋值给i

原子性问题举例

还是上文中的代码,10个线程将inc加到10000。假设在保证可见性的情况下,仍然会因为原子性问题导致执行结果达不到预期。为方便看,把代码贴到这里:

  1. public class Test {
  2. public int a = 0;
  3. public void increase() {
  4. a++;
  5. }
  6. public static void main(String[] args) {
  7. final Test test = new Test();
  8. for (int i = 0; i < 10; i++) {
  9. new Thread() {
  10. public void run() {
  11. for (int j = 0; j < 1000; j++)
  12. test.increase();
  13. };
  14. }.start();
  15. }
  16. while (Thread.activeCount() > 1) {
  17. // 保证前面的线程都执行完
  18. Thread.yield();
  19. }
  20. System.out.println(test.a);
  21. }
  22. }

目的:10个线程将inc加到10000。
结果:每次运行,得到的结果都小于10000。

原因分析:

首先来看a++操作,其实包括三个操作: 

①读取a=0; 

②计算0+1=1; 

③将1赋值给a; 

保证a++的原子性,就是保证这三个操作在一个线程没有执行完之前,不能被其他线程执行。

实际执行时序图如下:

关键一步:线程2在读取a的值时,线程1还没有完成a=1的赋值操作,导致线程2的计算结果也是a=1。

问题在于没有保证a++操作的原子性。如果保证a++的原子性,线程1在执行完三个操作之前,线程2不能执行a++,那么就可以保证在线程2执行a++时,读取到a=1,从而得到正确的结果。

有序性

有序性:程序执行的顺序按照代码的先后顺序执行。

编译器为了优化性能,有时候会改变程序中语句的先后顺序。例如程序中:“a=6;b=7;”编译器优化后可能变成“b=7;a=6;”,在这个例子中,编译器调整了语句的顺序,但是不影响程序的最终结果。不过有时候编译器及解释器的优化可能导致意想不到的Bug。

有序性问题举例

Java中的一个经典的案例:利用双重检查创建单例对象

  1. public class Singleton {
  2. static Singleton instance;
  3. static Singleton getInstance(){
  4. if (instance == null) {
  5. synchronized(Singleton.class) {
  6. if (instance == null)
  7. instance = new Singleton();
  8. }
  9. }
  10. return instance;
  11. }
  12. }

在获取实例getInstance()的方法中,我们首先判断 instance是否为空,如果为空,则锁定 Singleton.class并再次检查instance是否为空,如果还为空则创建Singleton的一个实例。
看似很完美,既保证了线程完全的初始化单例,又经过判断instance为null时再用synchronized同步加锁。但是还有问题!

instance = new Singleton(); 创建对象的代码,分为三步:
①分配内存空间
②初始化对象Singleton
③将内存空间的地址赋值给instance

但是这三步经过重排之后:
①分配内存空间
②将内存空间的地址赋值给instance
③初始化对象Singleton

会导致什么结果呢?

线程A先执行getInstance()方法,当执行完指令②时恰好发生了线程切换,切换到了线程B上;如果此时线程B也执行getInstance()方法,那么线程B在执行第一个判断时会发现instance!=null,所以直接返回instance,而此时的instance是没有初始化过的,如果我们这个时候访问instance的成员变量就可能触发空指针异常。

执行时序图:

总结

并发编程的本质就是解决三大问题:原子性、可见性、有序性。

原子性:一个或者多个操作在 CPU 执行的过程中不被中断的特性。由于线程的切换,导致多个线程同时执行同一段代码,带来的原子性问题。

可见性:一个线程对共享变量的修改,另外一个线程能够立刻看到。缓存不能及时刷新导致了可见性问题。

有序性:程序执行的顺序按照代码的先后顺序执行。编译器为了优化性能而改变程序中语句的先后顺序,导致有序性问题。

启发:线程的切换、缓存及编译优化都是为了提高性能,但是引发了并发编程的问题。这也告诉我们技术在解决一个问题时,必然会带来另一个问题,需要我们提前考虑新技术带来的问题以规避风险。


鲜花

握手

雷人

路过

鸡蛋

最新评论


QQ|Archiver|手机版|小黑屋| 零一零零 ( 京ICP备20003964号 ) |网站地图

GMT+8, 2020-10-31 17:24 , Processed in 0.044411 second(s), 17 queries .

Powered by Discuz! X3.4

© 2001-2013 Comsenz Inc.

返回顶部