什么是内存可见性

一个线程对主内存中的数据修改了，但是其他线程不可见。造成了内存可见性问题。

主内存是什么

存储共享变量

工作内存是什么

存储私有变量

  1. // 永不终止的循环 - 可见性问题
  2. public class TestInfinityLoop {
  3.     static boolean stop = false; //停止标记
  5.     public static void main(String[] args) throws InterruptedException {
  6.         Thread t = new Thread(() -> {
  7.             try {
  8.                 Thread.sleep(1000);
  9.             } catch (InterruptedException e) {
  10.                 e.printStackTrace();
  11.             }
  12.             stop = true; // volatile 的写
  13.             System.out.println("t线程内存：" + stop);
  14.         });
  15.         System.out.println("start " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
  16.         System.out.println("主线程内存：" + stop);
  17.         t.start();
  18.         //Thread t2 = new Thread(() -> {
  19.         //    try {
  20.         //        Thread.sleep(1000);
  21.         //    } catch (InterruptedException e) {
  22.         //        e.printStackTrace();
  23.         //    }
  24.         //    stop = true; // volatile 的写
  25.         //    System.out.println("t2线程内存：" + stop);
  26.         //});
  27.         //t2.start();
  28.         //System.out.println("主线程内存：" + stop);
  29.         foo();
  30.     }
  32.     private static void foo() {
  33.         while (true) {
  34.             boolean b = stop; // volatile 的读
  35.             if (b) {
  36.                 break;
  37.             }
  38.         }
  39.         System.out.println("end " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
  40.     }
  41. }

start 17:30:32 主线程内存：false t线程内存：true

这个代码和视频里讲的，启动两个线程，其中stop会将主内存中值修改为TRUE，实际上，一个线程的线程结果都是将主内存中的值改为TRUE。和多线程无关。
我们来看看两个线程的结果打印

  1. // 永不终止的循环 - 可见性问题
  2. public class TestInfinityLoop {
  3.     static boolean stop = false; //停止标记
  5.     public static void main(String[] args) throws InterruptedException {
  6.         Thread t = new Thread(() -> {
  7.             try {
  8.                 Thread.sleep(1000);
  9.             } catch (InterruptedException e) {
  10.                 e.printStackTrace();
  11.             }
  12.             stop = true; // volatile 的写
  13.             System.out.println("t线程内存：" + stop);
  14.         });
  15.         System.out.println("start " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
  16.         System.out.println("主线程内存：" + stop);
  17.         t.start();
  18.         Thread t2 = new Thread(() -> {
  19.             try {
  20.                 Thread.sleep(1000);
  21.             } catch (InterruptedException e) {
  22.                 e.printStackTrace();
  23.             }
  24.             stop = true; // volatile 的写
  25.             System.out.println("t2线程内存：" + stop);
  26.         });
  27.         t2.start();
  28.         System.out.println("主线程内存：" + stop);
  29.         foo();
  30.     }
  32.     private static void foo() {
  33.         while (true) {
  34.             boolean b = stop; // volatile 的读
  35.             if (b) {
  36.                 break;
  37.             }
  38.         }
  39.         System.out.println("end " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
  40.     }
  41. }

最终输出都是

start 17:30:12 主线程内存：false 主线程内存：false t2线程内存：true t线程内存：true

  1. 初始状态， t 线程刚开始从主内存读取了 run 的值到工作内存
    内存可见性 - 图1
    再尝试用 -Xint 强制解释执行
    禁用JIT编译器优化命令
    image.png
    上面的结果

    1. start 18:10:44
    2. 主线程内存：false
    3. t线程内存：true
    4. end 18:10:45

    再用 -XX:+PrintCompilation 看看实时编译后的代码
    image.png
    这个就代表着编译被优化了。

    解决方案

    加上volatile(易变)的关键字

    1. public class TestInfinityLoop {
    2.  volatile static boolean stop = false; //停止标记
    4.  public static void main(String[] args) throws InterruptedException {
    5.      Thread t = new Thread(() -> {
    6.          try {
    7.              Thread.sleep(1000);
    8.          } catch (InterruptedException e) {
    9.              e.printStackTrace();
    10.          }
    11.          stop = true; // volatile 的写
    12.          System.out.println("t线程内存：" + stop);
    13.      });
    14.      System.out.println("start " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
    15.      System.out.println("主线程内存：" + stop);
    16.      t.start();
    17.      foo();
    18.  }
    20.  private static void foo() {
    21.      while (true) {
    22.          boolean b = stop; // volatile 的读
    23.          if (b) {
    24.              break;
    25.          }
    26.      }
    27.      System.out.println("end " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
    28.  }
    29. }

    或者用synchronized解决

    1. public class TestInfinityLoop {
    2.  static boolean stop = false; //停止标记
    3.  private static final Object lock = new Object();
    5.  public static void main(String[] args) throws InterruptedException {
    6.      Thread t = new Thread(() -> {
    7.          try {
    8.              Thread.sleep(1000);
    9.          } catch (InterruptedException e) {
    10.              e.printStackTrace();
    11.          }
    12.          synchronized (lock) {
    13.              stop = true; // volatile 的写
    14.          }
    15.          System.out.println("t线程内存：" + stop);
    16.      });
    17.      System.out.println("start " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
    18.      System.out.println("主线程内存：" + stop);
    19.      t.start();
    20.      foo();
    21.  }
    23.  private static void foo() {
    24.      while (true) {
    25.          synchronized (lock) {
    26.              boolean b = stop; // volatile 的读
    27.              if (b) {
    28.                  break;
    29.              }
    30.          }
    31.      }
    32.      System.out.println("end " + LocalTime.now().format(DateTimeFormatter.ofPattern("HH:mm:ss")));
    33.  }
    34. }

    总结

    synchronized可以解决可见性、原子性、有序性，但是它是重型锁。而volatile能解决可见性和有序性，但不能解决原子性。