Java多线程之内存可见性

参考资料：细说Java多线程之内存可见性

一、基本概念

（一）、可见性

• 可见性：一个线程对共享变量的修改，能够及时被其他线程看到。
• 共享变量：若一个变量在多个线程的工作内存中都存在副本，那么这个变量就是这几个线程的共享变量。
• Java内存模型（JMM）：描述了Java程序中各种变量（线程共享变量）的访问规则，以及在JVM中将变量存储到内容和从内存中读取处变量这样的底层细节。

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

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

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

1、实现可见性要点

要实现共享变量的可见性，必须保证两点：

• 线程修改后的共享变量值能够及时从工作内存刷新到主内存中；
• 其他线程能够及时把共享变量的最新值从主内存更新到自己的工作内存中。

2、可见性的实现方式

• Java语言层面支持的可见性实现方式：synchronized和volatile。

二、synchronized实现可见性

synchronized能够实现：原子性（同步）和可见性。

• JMM关于synchronized的两条规定：

• 线程解锁(互斥锁)前，必须把共享变量的最新值刷新到主内存中；
• 线程加锁(互斥锁)时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值（加锁和解锁需用一把锁）。

• 重排序：

• 不可见原因及其解决方案

不可见的原因	synchronized的解决方案
线程的交叉执行	原子性
重排序结合线程交叉执行	原子性
共享变量未及时更新	可见性

public class SynchronizedDemo {
    /**
     * 共享变量
     */
    private boolean ready = false;
    private int result = 0;
    private int number = 1;

    /**
     * 写操作
     */
    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
        }
        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();
        try {
            //sleep后，一直为6
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //启动线程执行读操作
        synDemo.new ReadWriteThread(false).start();
    }
}
/**
 * 执行顺序：
 * 1.1->2.1->2.2->1.2  -->6
 * 1.2->2.1->2.2->1.1  -->0
 */

 

三、volatile实现可见性

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

• volatile如何实现内存可见性：通过加入内存屏障和禁止重排序优化来实现的。

• 对volatile变量执行写操作时，会在写操作后加入一条store屏障指令；
• 对volatile变量执行读操作时，会在读操作后加入一条load屏障指令。
• 通俗讲

1、volatile不能保证原子性

• volatile无原子性，结果不一定500。

public class VolatileDemo {
    private volatile int num = 0;

    public int getNum() {
        return this.num;
    }

    public void increase() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //无原子性
        this.num++;
    }

    public static void main(String[] args) {

        final VolatileDemo v1 = new VolatileDemo();
        for (int i = 0; i < 500; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    v1.increase();
                }
            }).start();
        }
        //如果还有主线程在运行, 主线程让出CPU资源,
        //直到所有的子线程运行完成, 主线程再继续执行下去
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println("num = " + v1.getNum());
    }
}

2、怎么保证原子性

• 第一种方案：synchronized保证可见性和原子性，结果一直500。

public class VolatileDemo {
    //synchronized保证可见性
    private int num = 0;

    public int getNum() {
        return this.num;
    }

    public void increase() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //保证原子性
        synchronized (this) {
            this.num++;
        }
    }

    public static void main(String[] args) {

        final VolatileDemo v1 = new VolatileDemo();
        for (int i = 0; i < 500; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    v1.increase();
                }
            }).start();
        }
        //如果还有主线程在运行, 主线程让出CPU资源,
        //直到所有的子线程运行完成, 主线程再继续执行下去
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println("num = " + v1.getNum());
    }
}

• 第二种方案：ReentrantLock加锁保证其原子性，结果一直500。

public class VolatileDemo {
    Lock lock = new ReentrantLock();
    private int num = 0;

    public int getNum() {
        return this.num;
    }

    public void increase() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //保证原子性
        lock.lock();
        try {
            this.num++;
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {

        final VolatileDemo v1 = new VolatileDemo();
        for (int i = 0; i < 500; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    v1.increase();
                }
            }).start();
        }
        //如果还有主线程在运行, 主线程让出CPU资源,
        //直到所有的子线程运行完成, 主线程再继续执行下去
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println("num = " + v1.getNum());
    }
}

3、volatile的使用场景

 

四、synchronized和volatile比较

• Synchronized保证内存可见性和操作的原子性
• Volatile只能保证内存可见性
• Volatile不需要加锁，比Synchronized更轻量级，并不会阻塞线程（volatile不会造成线程的阻塞；synchronized可能会造成线程的阻塞。）
• volatile标记的变量不会被编译器优化,而synchronized标记的变量可以被编译器优化（如编译器重排序的优化）.
• volatile是变量修饰符，仅能用于变量，而synchronized是一个方法或块的修饰符。

总结：volatile比synchronized更轻量级；volatile没有synchronized使用广泛。