共享变量可见性实现原理

多个线程共同使用的一个变量叫做共享变量。

线程对共享变量的所有操作都必须在自己的工作内存中进行，不能直接从主内存中读写。

不同线程之间无法直接访问其他线程工作内存中的变量，线程间变量的传递必须通过主内存完成。

java语言层面实现可见性的方式：

synchronized

volatile

synchronized实现可见性

synchronized最常见的一种理解是可以实现互斥锁，保证操作的原子性（同步）。同时，她也可以实现可见性。

JMM关于synchronize的两点规定：

线程解锁前，必须把共享变量的最新值刷新到主内存中去。
线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取共享变量的值（注意：加锁和解锁需要是同一把锁）
上述操作就可以实现在线程解锁前对共享变量的修改可以在下次加锁时对其他线程可见。
线程执行互斥代码的过程
1
2
3
4
5
6
获得互斥锁
清空工作内存
从主内存拷贝变量的最新副本到工作内存
执行代码
将更新后的共享变量的值刷新到主内存
释放互斥锁

补充知识

重排序

代码书写的顺序与实际执行的顺序不同，指令重排序是编译器或处理器为了提高程序性能而做的优化。共有三种：

编译器优化的重排序（编译器优化）
指令级并行重排序（处理器优化）

内存系统的重排序（处理器优化）

as-if-serial

无论如何重排序，程序执行的结果应该与代码顺序执行的结果一致。（java编译器、运行时和处理器都会保证java在单线程下遵循as-if-serial语义）

synchronized实现可见性代码

public class SynchronizedDemo {
    //共享变量
    private boolean ready = false;
    private int result = 0;
    private int number = 1;
    //写操作
    public void write(){
     ready = true;	//1.1
     number = 2;	//1.2
    }
    //读操作
    public void read(){
     if(ready){	//2.1
      result = number*3;	//2.2
     }
     System.out.println("result的值为：" + result);
    }
    //内部线程类
    private class ReadWriteThread extends Thread {
     //根据构造方法中传入的flag参数，确定线程执行读操作还是写操作
     private boolean flag;
     public ReadWriteThread(boolean flag){
      this.flag = flag;
     }
        @Override
        public void run() {
         if(flag){
          //构造方法中传入true，执行写操作
          write();
         }else{
          //构造方法中传入false，执行读操作
          read();
         }
        }
    }
    public static void main(String[] args) {
     SynchronizedDemo synDemo = new SynchronizedDemo();
     //启动线程执行写操作
     synDemo .new ReadWriteThread(true).start();
     //启动线程执行读操作
     synDemo.new ReadWriteThread(false).start();
    }
}

可见性分析

不可见的原因：

线程的交叉执行 –>原子性
重排序结合线程交叉执行 –>原子性

共享变量更新后的值没有在工作内存和主内存间及时更新 –>可见性

synchronized解决方案

加上synchronized 关键字后保证了执行代码的原子性，避免线程的交叉执行。

//写操作
    public synchronized void write(){
     ready = true;	//1.1
     number = 2;	//1.2
    }
    //读操作
    public synchronized void read(){
     if(ready){	//2.1
      result = number*3;	//2.2
     }

volatile实现可见性

volatile关键字：

能够保证volatile变量的可见性
不能保证volatile变量复合操作的原子性
volatile如何实现内存可见性
深入来说：通过加入内存屏障和禁止重排序优化来实现的。

对volatile变量执行写操作时，会在写操作后加入一条store屏障指令

store指令会强制刷新输入缓存，将改变的结果刷新到主内存中，同时能够禁止重排序的优化操作。

对volatile变量执行读操作时，会在读操作后加入一条load屏障指令
```
load指令会强制刷新工作内存，从主内存中获取变量，同时能够禁止重排序的优化操作。
```
线程写volatile变量的过程：

改变线程工作内存中volatile变量副本的值
将改变后的副本的值从工作内存刷新到主内存
线程读volatile变量的过程：
从主内存中读取volatile变量的最新值到线程的工作内存中
从工作内存中读取volatile变量的副本

volatile不能保证原子性

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class VolatileDemo {

 private 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++;  
 }
 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  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，但是不等于500的情况，这就是因为number++这步操作不属于原子操作造成的。

解决volatile不能保证自增操作原子性的问题

使用synchronized关键字
使用ReentrantLock（java.until.concurrent.locks包下，JDK1.5之后）

使用AtomicInterger（vava.util.concurrent.atomic包下，JDK1.5之后）
关于synchronized的使用，上文已经说过，下面演示一下ReentrantLock的使用：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.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) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  lock.lock();//加锁
  try {
   this.number++;
  } finally {
   lock.unlock();//不如执行结果如何都要进行解锁
  }
 }
 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  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());
 }
}

volatile的适用场景

在多线程中安全的适用volatile变量，必须同时满足两个条件：

对面变量的写入操作不依赖其当前值

不满足：number++、count=count*5等
满足：boolean变量、记录温度变化的变量等

该变量没有包含在具有其他变量的不定式中

不满足：low<up

synchronized和volatile的比较

volatile不需要加锁，比synchronize更轻量级，不会阻塞线程
从内存可见性的角度来讲，volatile的写操作相当于加锁，读操作相当于解锁
synchronized既能保证可见性又能保证原子性，而volatile只能保证可见性，不能保证原子性

补充：

对64位（double、long）变量的读写有可能不是原子操作：

Java内存模型(JMM)允许JVM将没有被volatile修饰的64位数据类型的读写操作划分成两次32位的读写操作来进行

导致的问题：有可能会出现读取到“半个变量”的情况
解决方法：添加volatile关键字