第五章共享模型之内存

无奈朝来寒雨晚来风

已于 2023-04-06 21:46:31 修改

阅读量384

点赞数 1

分类专栏： JUC并发编程文章标签： java jvm 开发语言

于 2023-03-31 23:00:54 首次发布

本文链接：https://blog.csdn.net/weixin_73198745/article/details/129877747

版权

JUC并发编程专栏收录该内容

11 篇文章 0 订阅

订阅专栏

JUC并发编程系列文章

http://t.csdn.cn/UgzQi

文章目录

JUC并发编程系列文章
前言
一、Java内存模型
二、内存的可见性
三、有序性
总结

前言

一、Java内存模型

主存是所有线程共享信息存贮的位置，而工作内存是每个线程私有的信息存贮的位置。

在这里插入图片描述

二、内存的可见性

退不出的循环：一个线程对主存进行修改，而另外一个线程不可见

在这里插入图片描述

解决内存不可见问题：使用 volatile（易变关键字）

volatile（易变关键字）
它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存

在这里插入图片描述

解决内存不可见问题：使用 synchronized 同步锁

synchronized也可以使内存可见达到 volatile 的效果，但是使用的是 Monitor重量级锁，而使用 volatile关键字更轻量级。

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.testThread18")
public class testThread18 {
      static boolean run = true;
     static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {

        Thread t = new Thread(()->{
            if(!run){
                synchronized (lock){
                    return;
                }
            }
        });
        t.start();

        Thread.sleep(1000);
        synchronized (lock){
            run = false; // synchronized也可以使内存可见 达到 volatile 的效果
        }

    }
}

可见性 VS 原子性

在这里插入图片描述

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.testThread18")
public class testThread18 {
      static boolean run = true;
     static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {

        Thread t = new Thread(()->{
            while (run){
                //  System.out.println("哈哈哈哈");因为其内部包含了synchronized 的使用，
                //  所以可以使内存可见 达到 volatile 的效果
                System.out.println("哈哈哈哈");

            }
        });
        t.start();

//        Thread.sleep(1000);

        run = false; 


    }
}

在这里插入图片描述

设计模式🍕

在这里插入图片描述

两阶段终止：volatile

import lombok.extern.slf4j.Slf4j;

/**
 * 两阶段终止设计模式volatile的代码实现
 */
@Slf4j(topic = "c.testThread03")
public class testThread03 {
    public static void main(String[] args) throws Exception{

        TwoStageTermination tst = new TwoStageTermination();
        tst.start();

        Thread.sleep(5000);

        tst.end();
    }
}

@Slf4j(topic = "c.TwoStageTermination")
class TwoStageTermination{
    private Thread monitor;

    //添加一个 volatile 标记
    static volatile boolean stop = false;

    public void start(){
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                while (true){
                    //判断是否被打断
                    if (stop){
                        log.debug("线程被打断...料理后事");
                        break;
                    }

                    try {
                        Thread.sleep(500);
                        log.debug("没有异常执行监控记录");
                    } catch (InterruptedException e) {

                    }

                }
            }
        };

        monitor = new Thread(runnable,"monitor");
        monitor.start();
    }

    public void end(){
        //打断监控
        log.debug("打断监控");
        //可有可无 monitor.interrupt();
        monitor.interrupt();
        stop = true;

    }
}

在这里插入图片描述

同步模式：Balking (犹豫模式)

在上面的监控例子中可以使线程 2 优雅的终止掉，但是对于启动监控的线程却没有限制，如果同一时间启用了多个线程就无法进性限制，可能出现一些无法预知的错误。所有可以使用犹豫模式，当进行方法的调用时先进行一些逻辑上的判断，看看是否真的需要进行业务逻辑的处理，这时在判断的时候更像我们人类的思考过程，犹豫不决。

在这里插入图片描述

import lombok.extern.slf4j.Slf4j;

/**
 * 两阶段终止设计模式volatile的代码实现
 */
@Slf4j(topic = "c.testThread03")
public class testThread03 {
    public static void main(String[] args) throws Exception{

        TwoStageTermination tst = new TwoStageTermination();
        tst.start();
        tst.start();

        Thread.sleep(5000);

        tst.end();
    }
}

@Slf4j(topic = "c.TwoStageTermination")
class TwoStageTermination{
    private Thread monitor;

    //添加一个 volatile 标记
    static volatile boolean stop = false;

    //添加一个 犹豫模式 标记
    static  boolean hesitate = false;

    public void start(){
        //不加锁还是使用 volatile 也是不行的，因为 volatile 是对线程所修改的结果可见性，而这时要考虑的是 犹豫标记还没有被修改
        synchronized (this){  //加锁防止 一个线程还没有修改标记，另外一个线程就进来执行
            //根据犹豫标记判断方法是否被其他线程调用过
            if(hesitate){
                //被调用过直接返回
                return;
            }
            //第一个线程调用后将 犹豫标记设置为 true 不让其他线程有可乘之机
            hesitate = true;
        }

        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                while (true){
                    //判断是否被打断
                    if (stop){
                        log.debug("线程被打断...料理后事");
                        break;
                    }

                    try {
                        Thread.sleep(500);
                        log.debug("没有异常执行监控记录");
                    } catch (InterruptedException e) {

                    }

                }
            }
        };

        monitor = new Thread(runnable,"monitor");
        monitor.start();
    }

    public void end(){
        //打断监控
        log.debug("打断监控");
        monitor.interrupt();
        stop = true;

    }
}

在这里插入图片描述

三、有序性

原理之指令级并行🔞

1、指令重排

在这里插入图片描述

2、指令重排原理：流水线工作机制

在这里插入图片描述

3、指令重排优化

在这里插入图片描述

4、支持流水线的处理器

现代 CPU 支持多级指令流水线，例如支持同时执行取指令 - 指令译码 - 执行指令 - 内存访问 - 数据写回的处理
器，就可以称之为五级指令流水线。这时 CPU 可以在一个时钟周期内，同时运行五条指令的不同阶段（相当于一
条执行时间最长的复杂指令），IPC = 1，本质上，流水线技术并不能缩短单条指令的执行时间，但它变相地提高了
指令地吞吐率。

在这里插入图片描述

指令重排序：诡异的结果

在操作系统层面和jvm虚拟机层面，都对指令进行了重排序的优化，指令的重排序在单线程的情况下不会有问题，但是在多线程的情况下就会有问题

在这里插入图片描述

volatile：禁止指令的重排序

在布尔变量的标记上添加一个 volatile 关键字就可以禁止指令的重排序，会在加了 volatile关键字的变量前的代码禁止重排序。

在这里插入图片描述

volatile原理🔞

volatile 只能保证可见性和有序性，但是不能保证多线程的原子性，也就是在 volatile 的写屏障之前，其他的线程来读取数据，本线程的volatile再提交后，其他的线程还是不能读到最新的数据，也就没有保持原子性。

而 synchronized 可以保证有序性，原子性，可见性。但是 synchronized 是Monitor重量级锁

在这里插入图片描述

1、如何保证可见性

在这里插入图片描述

2、如何保证有序性

在这里插入图片描述

3、double-checked locking 问题

按照视频里的解释是:
完全在synchronized作用域内的共享变量才能保证其原子性,可见性,有序性
这里 INSTANCE 并没有完全在 synchronized 作用域内,所以对其可能发生重排序
暂且这么理解吧,毕竟我没法证真也没法证伪

在这里插入图片描述

其中
● 17 表示创建对象，将对象引用入栈 // new Singleton
● 20 表示复制一份对象引用 // 引用地址
● 21 表示利用一个对象引用，调用构造方法
● 24 表示利用一个对象引用，赋值给 static INSTANCE

也许 jvm 会优化为：先执行 24，再执行 21。如果两个线程 t1，t2 按如下时间序列执行：

在这里插入图片描述

关键在于 0: getstatic 这行代码在 monitor 控制之外，它就像之前举例中不守规则的人，可以越过 monitor 读取INSTANCE 变量的值 .

这时 t1 还未完全将构造方法执行完毕，如果在构造方法中要执行很多初始化操作，那么 t2 拿到的是将是一个未初始化完毕的单例 .

对 INSTANCE 使用 volatile 修饰即可，可以禁用指令重排，但要注意在 JDK 5 以上的版本的 volatile 才会真正有效 .

4、DCL解决

在这里插入图片描述

字节码上看不出来 volatile 指令的效果

在这里插入图片描述

如上面的注释内容所示，读写 volatile 变量时会加入内存屏障（Memory Barrier（Memory Fence）），保证下面两点：
● 可见性
○ 写屏障（sfence）保证在该屏障之前的 t1 对共享变量的改动，都同步到主存当中
○ 而读屏障（lfence）保证在该屏障之后 t2 对共享变量的读取，加载的是主存中最新数据
● 有序性
○ 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
○ 读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前
● 更底层是读写变量时使用 lock 指令来多核 CPU 之间的可见性与有序性

在这里插入图片描述