JAVA 线程之内存可见性

什么是内存可见性

先介绍几个概念：

共享变量：

如果一个变量在多个线程的工作内存中都存在副本，那么这个变量就是这几个线程的共享变量

可见性：

一个线程对共享变量值的修改，能够及时地被其他线程看到

JMM（ JAVA内存模型）

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

这里我们只需要知道：

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

它有两条规定：

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

因此要想实现线程1对共享变量的修改被线程2及时看到，要经过两个步骤：

1. 把工作内存1中更新过的共享变量刷新到主内存

2.把主内存中更新过的共享变量刷新到工作内存2

Synchronized实现可见性

先了解下重排序和as-if-serial语句的概念

重排序

代码书写的顺序和实际执行的顺序不同

代码顺序

    int number = 1;
    int result = 0;

执行顺序

    int result = 0;
    int number = 1;

原因是编译器或者处理器为了提高程序性能做的优化

1. 编译器优化的重排序 （编译器优化）
2. 指令级并行重排序（处理器优化）
3. 内存系统的重排序（处理器优化）

as-if-serial

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

    int num1 = 1;
    int num2 = 2;
    int sum = num1 + num2;

单线程：第1，2行顺序可以重排 但是第3行不行

重排序不会给单线程带来内存可见性问题

多线程中程序交错执行时可能会造成内存可见性问题

Synchronized可以实现：

• 原子性 （同步）
• 可见性

可见性

JMM关于Synchronized的两条规定：

1. 线程解锁前，必须把共享变量的最新值刷新到主内存中
2. 线程加锁时，将清空工作内存中的共享变量的值，从而使用共享变量时都必须从主内存中重新读取最新的值

因此线程解锁前对共享变量的修改在下次加锁时对其他线程是可见的

线程执行互斥代码的过程：

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

代码示例：

package thread.sychronized;

/**
 * SyncDemo
 * Created by heqianqian on 2017/4/15.
 */
public class SyncDemo {

    private boolean ready = false;
    private int value = 2;
    private int result = 0;

    private synchronized void read() {
        if(ready){
            result = value*3;
        }
        System.out.println("result的值为：" + result);
    }

    private synchronized void write() {
        ready = true;
        value = 10;
    }

    private class MyThread extends Thread{

        private boolean flag;

        public MyThread(boolean flag) {
            this.flag = flag;
        }

        @Override
        public void run() {
            if (flag){
                write();
            }else{
                read();
            }
        }
    }

    public static void main(String[] args) {
        SyncDemo syncDemo = new SyncDemo();
        //写操作
        syncDemo.new MyThread(true).start();
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //读操作
        syncDemo.new MyThread(false).start();
    }

}

Volatile实现可见性

通过加入内存屏障和禁止重排序优化来实现

• 对volatile变量进行写操作时 会在写操作后加入一条store屏障指令
• 对volatile变量进行写操作时 会在读操作前加入一条load屏障指令

通俗的来说：

volatile变量在每次被线程访问时，都强迫从主内存中读取该变量的值，而当该变量发生改变时，又会强迫把最近的值刷新到主内存中

volatile不能保证符合操作的原子性

保证操作的原子性

1. 使用synchronized
2. 用ReentranLock实现

要在多线程中安全的使用volatile变量 必须同时满足

1. 对变量的写入操作不依赖当前值
2. 变量没有包含在具有其他变量的不变式中