(1)内存可见性

一个线程修改了对象状态后, 其他线程能够看到发生的状态变化

(2) 重排序

在其他线程中，可以观察到某个线程中的操作没有按照程序中指定的顺序来执行

注

1° 在缺少同步的情况下, Java内存模型允许编译器对操作顺序进行重排序, 并将数值缓存在寄存器中;

2° Java内存模型还允许CPU对操作顺序进行重排序, 并将数值缓存在处理器特定的缓存中

(3) 示例

  public class NoVisibility {

      private static boolean ready;
      private static int number;

      private static class ReaderThread extends Thread {

          public void run() {

              while (!ready) {
                  Thread.yield();
              }

          System.out.println(number);
      }
  }

  public static void main(String[] args) {

      new ReaderThread().start();

      number = 42;
      ready = true;
  }

}

输出可能是42(正常情况), 可能是0(重排序导致ready = true先执行,然后执行ReaderThread线程的run,输出ready的默认初始值0), 还有可能程序无法终止(因为ready=true没有同步回主内存导致ReaderThread看不到它的值，一直在while循环中)

失效数据

(1) 当对状态变量的访问更新缺乏同步时, 可能会获得失效的数据

示例1

  @NotThreadSafe
  public class MutableInteger {
      
      private int value;

      public int get() {
          return value;
      }

      public void set(int value) {
          this.value = value;
      }
  }

示例2

  @NotThreadSafe
  public class SynchronizedInteger {

      private int value;

      public int get() {
          return value;
      }

      public synchronized void set(int value) {
          this.value = value;
      }
  }

示例3

  @ThreadSafe
  public class SynchronizedInteger {

      private int value;

      public synchronized int get() {
          return value;
      }

      public synchronized void set(int value) {
          this.value = value;
      }
  }

示例1和示例2都可能会产生数据失效问题, 而示例3则不会。因为synchronized使用同一个锁时,保证了在拥有锁的线程释放锁以前,会将数值同步回主内存;读变量值也会从主内存读,所以拥有同一把锁的两个线程将会看到相同的变量值。

注意,不能只对set加synchronized,get也要加上，原因见上面。

非原子的64位操作

(1) 非volatile的64位数值变量(double, long)的不保证读操作和写操作的原子性

也就是说, 可能一个线程刚写了32位就被打断执行下一个读变量的线程

(2) __因此, 在多线程环境下, 要用volatile或锁来保护64位数值变量的读写

加锁(synchronized)不仅仅可以实现原子性(或确定临界区), 还保证了内存可见性!!!_

volatile

(1) volatile变量的保证

1° 编译器和运行时发现了一个volatile变量, 会保证对该变量的操作不会与其他内存操作一起重排序

2° 保证了volatile变量不会被缓存在寄存器或者其他对其他处理器不可见的地方

(2) 添加了volatile的变量，可以理解为在读变量和写变量值的时候使用了synchronized get()和synchronized set() (其实不是完全等效)

(3) 在访问volatile变量时不会有加锁解锁操作, 因此不会使线程阻塞 ---> volatile是一种轻量级的同步机制

(4) synchronized可以保证原子性+可见性(+有序性), 而volatile只能保证可见性(+有序性)

因此,volatile的常见应用场景是作为某个操作完成、中断的标志(flag)

应用示例

  public class CountingSheep {

      volatile private boolean asleep;

      void tryToSleep() {
  
          while (!asleep) {
              countSomeSheep();
          }
      }

      private void countSomeSheep() {
          // One, two, three...
      }
  }