Java多线程之内存可见性

可见性基本介绍

基本概念

• 可见性：一个线程对共享变量值的修改，能够及时地被其他线程看到。
• 共享变量：如果一个变量在多个线程的工作内存中都存在副本，那么这个变量就是共享变量。
• 工作内存：JMM描述了变量访问规则，以及从内存中读取变量的底层细节。

内存基本规则

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

共享变量可见性原理

倘若线程1对共享变量的修改要想被线程2及时看到，必须要经过如下两个步骤：

• 把工作内存1中更新过的变量刷新到主内存中
• 将主内存的最新共享变量的值更新到线程2的工作内存当中

synchronized实现可见性

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

JMM关于synchronized的规定

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

线程执行互斥代码的过程

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

指令重排

目的：代码书写的顺序与实现执行顺序不同，指令重排是编译器或者处理器为了提高程序性能而做的优化
1、编译器优化
2、指令级并行重排序（处理器优化）
3、内存系统优化（处理器优化）
4、as-if-serial：无论如何重排序，执行结果应该与代码顺序执行的结果一致
5、单线程不会因指令重排产生内存可见性问题

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

1、线程的交叉执行
2、重排序结合线程交叉执行
3、共享变量更新后的值没有在工作内存中与主内存间及时更新

synchronized解决方案

• 保证内部操作的原子性（解决问题1、2）
• 提供内存可见性规范（解决问题3）

package SynchronizedDemo;public class SynchronizedDemo {    // 共享变量    private boolean ready = false;    private int result = 0;    private int number = 1;    // 写操作    public synchronized void write() {        ready = true;        number = 2;    }    // 读操作    public synchronized void read() {        if (ready) {            result = number * 3;        }        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 {                // 构造方法传入flase执行读操作                read();            }        }    }    public static void main(String[] args) {        SynchronizedDemo synDemo = new SynchronizedDemo();        // 启动线程执行写操作        synDemo.new ReadWriteThread(true).start();        try {            // 进行延迟保证写线程先执行完毕            Thread.sleep(1000);        } catch (InterruptedException e) {            e.printStackTrace();        }        // 启动线程执行读操作        synDemo.new ReadWriteThread(false).start();    }}

volatile实现内存可见性

• 通过内存屏障和指令重排优化来实现
• 对volatile变量执行写操作时，会在写操作后加一条store指令，强制刷新值到内存中
• 对volatile变量执行读操作时，会在写操作后加一条load指令，使工作内存中的值无效，而到内存中获取最新的值
• volatile不能保证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) {            e.printStackTrace();        }        this.number++;    }    public static void main(String[] args) {        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。volatile无法保证复合操作的原子性

保证number自增操作原子性的解决方案

• 使用synchronized关键字
• 使用reentrantlock
• 使用AtomicInterger

使用synchronized关键字

public void increase() {        try {            Thread.sleep(100);        } catch (InterruptedException e) {            e.printStackTrace();        }        synchronized (this) {            this.number++;        }    }

使用reentrantlock

public void increase() {        try {            Thread.sleep(100);        } catch (InterruptedException e) {            e.printStackTrace();        }        lock.lock();        try {            this.number++;        } finally {            lock.unlock();        }    }

volatile注意事项

适用场合（必须同时满足）

1、对变量的写入操作不依赖其当前值，即这次变量的值修改与之前无关

count++就是反例，自增操作依赖于当前值。场景：布尔变量、当前温度。

2、该变量没有包含在具有其他变量的不变式中。

反例：low < up

volatile与synchronized比较

• volatile不需要加锁，轻量级，执行效率高，不阻塞线程。
• volatile读相当于加锁，写相当于解锁
• synchronized即能保证可见性又能保证原子性，而volatile只能保证可见性。