个人博客请访问 http://www.x0100.top
写在前面
编写并发程序是比较困难的,因为并发程序极易出现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 &#61; 0; i <10; i&#43;&#43;) {
new Thread() {
public void run() {
for (int j &#61; 0; j <1000; j&#43;&#43;)test.increase();};}.start();}while (Thread.activeCount() > 1) {
// 保证前面的线程都执行完Thread.yield();}System.out.println(test.a);}
}
目的&#xff1a;10个线程将inc加到10000。
结果&#xff1a;每次运行&#xff0c;得到的结果都小于10000。
原因分析&#xff1a;
假设线程1和线程2同时开始执行&#xff0c;那么第一次都会将a&#61;0 读到各自的CPU缓存里&#xff0c;线程1执行a&#43;&#43;之后a&#61;1&#xff0c;但是此时线程2是看不到线程1中a的值的&#xff0c;所以线程2里a&#61;0&#xff0c;执行a&#43;&#43;后a&#61;1。
线程1和线程2各自CPU缓存里的值都是1&#xff0c;之后线程1和线程2都会将自己缓存中的a&#61;1写入内存&#xff0c;导致内存中a&#61;1&#xff0c;而不是我们期望的2。所以导致最终 a 的值都是小于 10000 的。这就是缓存的可见性问题。
原子性
原子性是什么&#xff1f;
把一个或者多个操作在 CPU 执行的过程中不被中断的特性称为原子性。
在并发编程中&#xff0c;原子性的定义不应该和事务中的原子性&#xff08;一旦代码运行异常可以回滚&#xff09;一样。应该理解为&#xff1a;一段代码&#xff0c;或者一个变量的操作&#xff0c;在一个线程没有执行完之前&#xff0c;不能被其他线程执行。
为什么会有原子性问题&#xff1f;
线程是CPU调度的基本单位。CPU会根据不同的调度算法进行线程调度&#xff0c;将时间片分派给线程。当一个线程获得时间片之后开始执行&#xff0c;在时间片耗尽之后&#xff0c;就会失去CPU使用权。多线程场景下&#xff0c;由于时间片在线程间轮换&#xff0c;就会发生原子性问题。
如&#xff1a;对于一段代码&#xff0c;一个线程还没执行完这段代码但是时间片耗尽&#xff0c;在等待CPU分配时间片&#xff0c;此时其他线程可以获取执行这段代码的时间片来执行这段代码&#xff0c;导致多个线程同时执行同一段代码&#xff0c;也就是原子性问题。
线程切换带来原子性问题。
在Java中&#xff0c;对基本数据类型的变量的读取和赋值操作是原子性操作&#xff0c;即这些操作是不可被中断的&#xff0c;要么执行&#xff0c;要么不执行。
i &#61; 0; // 原子性操作
j &#61; i; // 不是原子性操作&#xff0c;包含了两个操作&#xff1a;读取i&#xff0c;将i值赋值给j
i&#43;&#43;; // 不是原子性操作&#xff0c;包含了三个操作&#xff1a;读取i值、i &#43; 1 、将&#43;1结果赋值给i
i &#61; j &#43; 1; // 不是原子性操作&#xff0c;包含了三个操作&#xff1a;读取j值、j &#43; 1 、将&#43;1结果赋值给i
原子性问题举例
还是上文中的代码&#xff0c;10个线程将inc加到10000。假设在保证可见性的情况下&#xff0c;仍然会因为原子性问题导致执行结果达不到预期。为方便看&#xff0c;把代码贴到这里&#xff1a;
public class Test {
public int a &#61; 0;public void increase() {a&#43;&#43;;}public static void main(String[] args) {
final Test test &#61; new Test();
for (int i &#61; 0; i <10; i&#43;&#43;) {
new Thread() {
public void run() {
for (int j &#61; 0; j <1000; j&#43;&#43;)test.increase();};}.start();}while (Thread.activeCount() > 1) {
// 保证前面的线程都执行完Thread.yield();}System.out.println(test.a);}
}
目的&#xff1a;10个线程将inc加到10000。
结果&#xff1a;每次运行&#xff0c;得到的结果都小于10000。
原因分析&#xff1a;
首先来看a&#43;&#43;操作&#xff0c;其实包括三个操作&#xff1a;
①读取a&#61;0;
②计算0&#43;1&#61;1;
③将1赋值给a;
保证a&#43;&#43;的原子性&#xff0c;就是保证这三个操作在一个线程没有执行完之前&#xff0c;不能被其他线程执行。
实际执行时序图如下&#xff1a;
关键一步&#xff1a;线程2在读取a的值时&#xff0c;线程1还没有完成a&#61;1的赋值操作&#xff0c;导致线程2的计算结果也是a&#61;1。
问题在于没有保证a&#43;&#43;操作的原子性。如果保证a&#43;&#43;的原子性&#xff0c;线程1在执行完三个操作之前&#xff0c;线程2不能执行a&#43;&#43;&#xff0c;那么就可以保证在线程2执行a&#43;&#43;时&#xff0c;读取到a&#61;1&#xff0c;从而得到正确的结果。
有序性
有序性&#xff1a;程序执行的顺序按照代码的先后顺序执行。
编译器为了优化性能&#xff0c;有时候会改变程序中语句的先后顺序。例如程序中&#xff1a;“a&#61;6&#xff1b;b&#61;7&#xff1b;”编译器优化后可能变成“b&#61;7&#xff1b;a&#61;6&#xff1b;”&#xff0c;在这个例子中&#xff0c;编译器调整了语句的顺序&#xff0c;但是不影响程序的最终结果。不过有时候编译器及解释器的优化可能导致意想不到的Bug。
有序性问题举例
Java中的一个经典的案例&#xff1a;利用双重检查创建单例对象
public class Singleton {static Singleton instance;static Singleton getInstance(){if (instance &#61;&#61; null) {synchronized(Singleton.class) {if (instance &#61;&#61; null)instance &#61; new Singleton();}}return instance;}
}
在获取实例getInstance()的方法中&#xff0c;我们首先判断 instance是否为空&#xff0c;如果为空&#xff0c;则锁定 Singleton.class并再次检查instance是否为空&#xff0c;如果还为空则创建Singleton的一个实例。
看似很完美&#xff0c;既保证了线程完全的初始化单例&#xff0c;又经过判断instance为null时再用synchronized同步加锁。但是还有问题&#xff01;
instance &#61; new Singleton();
创建对象的代码&#xff0c;分为三步&#xff1a;
①分配内存空间
②初始化对象Singleton
③将内存空间的地址赋值给instance
但是这三步经过重排之后&#xff1a;
①分配内存空间
②将内存空间的地址赋值给instance
③初始化对象Singleton
会导致什么结果呢&#xff1f;
线程A先执行getInstance()方法&#xff0c;当执行完指令②时恰好发生了线程切换&#xff0c;切换到了线程B上&#xff1b;如果此时线程B也执行getInstance()方法&#xff0c;那么线程B在执行第一个判断时会发现instance!&#61;null&#xff0c;所以直接返回instance&#xff0c;而此时的instance是没有初始化过的&#xff0c;如果我们这个时候访问instance的成员变量就可能触发空指针异常。
执行时序图&#xff1a;
总结
并发编程的本质就是解决三大问题&#xff1a;原子性、可见性、有序性。
原子性&#xff1a;一个或者多个操作在 CPU 执行的过程中不被中断的特性。由于线程的切换&#xff0c;导致多个线程同时执行同一段代码&#xff0c;带来的原子性问题。
可见性&#xff1a;一个线程对共享变量的修改&#xff0c;另外一个线程能够立刻看到。缓存不能及时刷新导致了可见性问题。
有序性&#xff1a;程序执行的顺序按照代码的先后顺序执行。编译器为了优化性能而改变程序中语句的先后顺序&#xff0c;导致有序性问题。
启发&#xff1a;线程的切换、缓存及编译优化都是为了提高性能&#xff0c;但是引发了并发编程的问题。这也告诉我们技术在解决一个问题时&#xff0c;必然会带来另一个问题&#xff0c;需要我们提前考虑新技术带来的问题以规避风险。