Java并发一：Java并发编程三大核心

编写并发程序是比较困难的，因为并发程序极易出现Bug，这些Bug有都是比较诡异的，很多都是没办法追踪，而且难以复现。 要快速准确的发现并解决这些问题，首先就是要弄清并发编程的本质，并发编程要解决的是什么问题。 本文将带你深入理解并发编程要解决的三大问题：原子性、可见性、有序性。 补充知识 硬件的发展中，一直存在一个矛盾，CPU、内存、I/O设备的速度差异。 速度排序：CPU >> 内存 >> I/O设备 为了平衡这三者的速度差异，做了如下优化： CPU 增加了缓存，以均衡内存与CPU的速度差异； 操作系统增加了进程、线程，以分时复用CPU，进而均衡I/O设备与CPU的速度差异； 编译程序优化指令执行次序，使得缓存能够得到更加合理地利用。 可见性 可见性是什么？ 一个线程对共享变量的修改，另外一个线程能够立刻看到，我们称为可见性。 为什么会有可见性问题？ 对于如今的多核处理器，每颗CPU都有自己的缓存，而缓存仅仅对它所在的处理器可见，CPU缓存与内存的数据不容易保证一致。 为了避免处理器停顿下来等待向内存写入数据而产生的延迟，处理器使用写缓冲区来临时保存向内存写入的数据。写缓冲区合并对同一内存地址的多次写，并以批处理的方式刷新，也就是说写缓冲区不会即时将数据刷新到主内存中。 缓存不能及时刷新导致了可见性问题。 可见性问题举例 public class Test { public int a = 0; public void increase() { a++; } public static void main(String[] args) { final Test test = new Test(); for (int i = 0; i < 10; i++) { new Thread() { public void run() { for (int j = 0; j < 1000; j++) test.increase(); }; }.start(); } while (Thread.activeCount() > 1) { // 保证前面的线程都执行完 Thread.yield(); } System.out.println(test.a); } } 目的：10个线程将inc加到10000。 结果：每次运行，得到的结果都小于10000。 原因分析： img 假设线程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中，对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么执行，要么不执行。 i = 0; // 原子性操作 j = i; // 不是原子性操作，包含了两个操作：读取i，将i值赋值给j i++; // 不是原子性操作，包含了三个操作：读取i值、i + 1 、将+1结果赋值给i i = j + 1; // 不是原子性操作，包含了三个操作：读取j值、j + 1 、将+1结果赋值给i 原子性问题举例 还是上文中的代码，10个线程将inc加到10000。假设在保证可见性的情况下，仍然会因为原子性问题导致执行结果达不到预期。为方便看，把代码贴到这里： public class Test { public int a = 0; public void increase() { a++; } public static void main(String[] args) { final Test test = new Test(); for (int i = 0; i < 10; i++) { new Thread() { public void run() { for (int j = 0; j < 1000; j++) test.increase(); }; }.start(); } while (Thread.activeCount() > 1) { // 保证前面的线程都执行完 Thread.yield(); } System.out.println(test.a); } } 目的：10个线程将inc加到10000。 结果：每次运行，得到的结果都小于10000。 原因分析： 首先来看a++操作，其实包括三个操作： ①读取a=0; ②计算0+1=1; ③将1赋值给a; 保证a++的原子性，就是保证这三个操作在一个线程没有执行完之前，不能被其他线程执行。 实际执行时序图如下： img 关键一步：线程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中的一个经典的案例：利用双重检查创建单例对象 public class Singleton { static Singleton instance; static Singleton getInstance(){ if (instance == null) { synchronized(Singleton.class) { if (instance == null) instance = new Singleton(); } } return instance; } } 在获取实例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的成员变量就可能触发空指针异常。 执行时序图： img 总结 并发编程的本质就是解决三大问题：原子性、可见性、有序性。 原子性：一个或者多个操作在 CPU 执行的过程中不被中断的特性。由于线程的切换，导致多个线程同时执行同一段代码，带来的原子性问题。 可见性：一个线程对共享变量的修改，另外一个线程能够立刻看到。缓存不能及时刷新导致了可见性问题。 有序性：程序执行的顺序按照代码的先后顺序执行。编译器为了优化性能而改变程序中语句的先后顺序，导致有序性问题。 启发：线程的切换、缓存及编译优化都是为了提高性能，但是引发了并发编程的问题。这也告诉我们技术在解决一个问题时，必然会带来另一个问题，需要我们提前考虑新技术带来的问题以规避风险。 如果你有学到，请给我点赞?+关注，这是对小编的最大支持！千篇一律的皮囊，万里挑一的灵魂，一个不太一样的写手。

本文章由javascript技术分享原创和收集