线程安全性问题可以总结为：可见性、原子性、有序性这几个问题，接下来我们通过代码来复现可见性、原子性的问题，后面章节我会从原理层面去分析这些问题。

可见性

  1. public class VisibleDemo {
  3.     private static boolean stop = false;
  5.     public static void main(String[] args) {
  6.         Thread thread = new Thread(new Runner());
  7.         thread.start();
  8.         try {
  9.             TimeUnit.SECONDS.sleep(1);
  10.         } catch (InterruptedException e) {
  11.             e.printStackTrace();
  12.         }
  13.         stop = true;
  14.     }
  16.     private static class Runner implements Runnable {
  18.         private int i;
  20.         @Override
  21.         public void run() {
  22.             while (!stop) {
  23.                 i++;
  24.             }
  25.             System.out.println(i);
  26.         }
  27.     }
  28. }

在 main 方法中把 stop 变量改为 true，理论上线程应该终止，但是一般情况下，子线程一直在运行没有终止。说明在 main 线程中改变 stop 的值没有被子线程获取到，这就是多线程环境下的可见性问题。

原子性

  1. public class AtomicDemo {
  3.     private static int count;
  5.     public static void main(String[] args) {
  6.         for (int i = 0; i < 1000; i++) {
  7.             new Thread(new Runner()).start();
  8.         }
  9.         try {
  10.             Thread.sleep(4000);
  11.         } catch (InterruptedException e) {
  12.             e.printStackTrace();
  13.         }
  14.         System.out.println("运行结果：" + count);
  15.     }
  17.     private static class Runner implements Runnable {
  19.         @Override
  20.         public void run() {
  21.             try {
  22.                 Thread.sleep(1);
  23.             } catch (InterruptedException e) {
  24.                 e.printStackTrace();
  25.             }
  26.             count++;
  27.         }
  28.     }
  29. }

在 main 方法中，循环创建1000个线程执行 count++，理论上 count 最终的运行结果应该是1000，但是我们发现运行结果会出现小于等于1000的情况，这就是多线程环境下的原子性问题。

  1. 运行结果：973

我们可能存在如下疑问：

  • 在属性 count 前面加上 volatile 关键字能否解决原子性问题？
  • 为什么 count++; 会存在原子性问题呢，它不是只有一条命令么？

注意：count++; 不是原子操作，通过 javap **命令反汇编查看如下代码的指令信息。**

  1. public class Test {
  3.     private int count = 0;
  5.     public void incr() {
  6.         count++;
  7.     }
  9.     public static void main(String[] args) {
  10.         new Test().incr();
  11.     }
  12. }
  1. public class test3.Test {
  2.   public test3.Test();
  3.     Code:
  4.        0: aload_0
  5.        1: invokespecial #10                 // Method java/lang/Object."<init>":()V
  6.        4: aload_0
  7.        5: iconst_0
  8.        6: putfield      #12                 // Field count:I
  9.        9: return
  11.   public void incr();
  12.     Code:
  13.        0: aload_0
  14.        1: dup
  15.        2: getfield      #12                 // Field count:I
  16.        5: iconst_1
  17.        6: iadd
  18.        7: putfield      #12                 // Field count:I
  19.       10: return
  21.   public static void main(java.lang.String[]);
  22.     Code:
  23.        0: new           #1                  // class test3/Test
  24.        3: dup
  25.        4: invokespecial #21                 // Method "<init>":()V
  26.        7: invokevirtual #22                 // Method incr:()V
  27.       10: return
  28. }

通过上面的指令信息发现，count++ 其实是由三条指令组合的复合操作。

  1. getfield
  2. iadd
  3. putfield

volatile 关键字不能解决复合操作的原子性问题，所以在属性 count 前面增加 volatile 关键字不能解决原子性问题。

有序性

指的是在程序运行过程中，代码的执行顺序和我们编写代码的顺序可能是不一致的，因为在执行程序时，为了提高性能，编译器和处理器常常会对指令做重排序。

作者：殷建卫 链接：https://www.yuque.com/yinjianwei/vyrvkf/ygfq5z 来源：殷建卫 - 架构笔记 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。