Java多线程之内存可见性

最新推荐文章于 2020-06-17 11:43:17 发布

萌新白给

最新推荐文章于 2020-06-17 11:43:17 发布

阅读量238

点赞数

分类专栏： Java高阶文章标签： java 多线程内存工作线程

本文链接：https://blog.csdn.net/ggsimida2016/article/details/72629956

版权

Java高阶专栏收录该内容

2 篇文章 0 订阅

订阅专栏

可见性基本介绍

基本概念

可见性：一个线程对共享变量值的修改，能够及时地被其他线程看到。
共享变量：如果一个变量在多个线程的工作内存中都存在副本，那么这个变量就是共享变量。
工作内存：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();
        }
    }