JAVA学习笔记-----可见性（synchronized/volatile）

概念

可见性：一个线程对共享变量值的修改，能够及时地被其他线程看到。
共享变量：如果一个变量在多个线程的工作内存中都存在副本，那么这个变量就是这几个线程的共享变量。

Java内存模型（JMM）

Java内存模型（Java Memory Model）描述了Java程序中各种变量（线程共享变量）的访问规则，以及在JVM中将变量存储到内存和从内存中读取出变量这样的底层细节。

1. 所有的变量都存储在主内存中
2. 每个线程都有自己独立的工作内存，里面保存该线程使用到的变量的副本（主内存中该变量的一份拷贝）
   

两条规定

1. 线程对共享变量的所有操作都必须在自己的工作内存中进行，不能直接从主内存中读写。
2. 不同线程之间无法直接访问其他线程工作内存中的变量，线程间变量值的传递需要通过主内存来完成。

共享变量可见性实现的原理

线程1对共享变量的修改要想被线程2及时看到，必须经过如下2个步骤：
1）把工作内存1中更新过的共享变量刷新到主内存中
2）将主内存中最新的共享变量的值更新到工作内存2中

语言层面实现方式

synchronized实现可见性

1. 原子性(同步)
2. 可见性

JMM关于synchronized的两条规定

1. 线程解锁前，必须把共享变量的最新值刷新到主内存中
2. 线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值（注意：加锁与解锁需要是同一把锁）
   线程解锁前对共享变量的修改在下次加锁时对其他线程可见。

线程执行互斥代码的过程

1. 获得互斥锁
2. 清空工作内存
3. 从主内存拷贝变量的最新副本到工作内存
4. 执行代码
5. 将更改后的共享变量的值刷新到主内存
6. 释放互斥锁

导致共享变量在线程间不可见的原因

1. 线程的交叉执行—–>synchronized的原子性解决了
2. 重排序结合线程交叉执行—–>synchronized的原子性解决了
3. 共享变量更新后的值没有在工作内存与主内存间及时更新—–>synchronized的可见性解决了

synchronized选择题

错误的是C。
解析：当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将会被阻塞。
自己的理解：该线程持有了该对象实例的对象锁。

• 静态方法加锁：相当于给类加锁(静态方法会有一个公用的对象，用来调用静态方法)，这时候，只要是这个类产生的对象，在调用这个静态方法时都会产生互斥。
• 非静态方法加锁：给该对象加锁，但别的线程仍可以访问别的对象的同步方法。

volatile实现可见性

• 能够保证volatile变量的可见性
• 不能保证volatile变量复合操作的原子性

volatile如何实现内存可见性

深入来说：通过加入内存屏障和禁止重排序优化来实现的。
- 对volatile变量执行写操作时，会在写操作后加入一条store屏障指令
- 对volatile变量执行读操作时，会在读操作前加入一条load屏障指令
通俗的讲：volatile变量在每次被线程访问时，都强迫从主内存中重读该变量的值，而当该变量发生变化时，又会强迫线程将最新的值刷新到主内存。这样任何时刻，不同的线程总能看到该变量的最新值。

线程写volatile变量的过程

1. 改变线程工作内存中volatile变量副本的值
2. 将改变后的副本的值从工作内存刷新到主内存

线程读volatile变量的过程

1. 从主内存中读取volatile变量的最新值到线程的工作内存中
2. 从工作内存中读取volatile变量的副本

volatile不能保证原子性

代码如下：

public class VolatileDemo {
  private volatile int number = 0;

  public int getNumber() {
    return this.number;
  }

  public void increase() {
    try {
      Thread.sleep(100);// 使结果明显
    } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    this.number++;
  }

  public static void main(String[] args) {
    final VolatileDemo volDemo = new VolatileDemo();
    for (int i = 0; i < 500; i++) {
      new Thread(new Runnable() {

        @Override
        public void run() {
          volDemo.increase();
        }
      }).start();
    }
    // 如果还有子线程在运行，主线程就让出CPU，
    // 直到所有的子线程都运行完了。主线程再继续往下执行
    while (Thread.activeCount() > 1) {
      Thread.yield();
    }
    System.out.println("number: " + volDemo.getNumber());
  }
}

结果常常小于500，因为number++不是原子操作，而volatile也不能保证该变量的原子性。

解决办法：

• 使用synchronized关键字
• 使用ReentrantLock（java.util.concurrent.locks包下）
• 使用AtomicInterger（java.util.concurrent.atomic包下）

ReentrantLock程序举例：

public class VolatileDemo {
  //新加入代码
  private Lock lock = new ReentrantLock();
  private int number = 0;

  public int getNumber() {
    return this.number;
  }

  public void increase() {
    try {
      Thread.sleep(100);
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    //新加入代码
    lock.lock();
    //需要把执行代码放入try...finally中，在finally中调用lock.unlock()，防止执行过程中抛出异常，保证锁一定会被释放。
    try {
      this.number++;
    } finally {
      lock.unlock();
    }
  }
}

volatile适用场合

1. 对变量的写入操作不依赖其当前值
   不满足：number++、count=count*5等
   满足：boolean变量等
2. 该变量没有包含在具有其他变量的不变式中
   不满足：low和up都是volatile修饰的变量，则不变式 low

synchronized和volatile比较