1_基础知识_chapter03_对象的共享_1_可见性

• (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...
        }
    }