7、共享模型之内存（可见性、原子性、有序性；volatie原理以及使用案例、happens-before）

最新推荐文章于 2024-08-12 15:45:48 发布

香树

最新推荐文章于 2024-08-12 15:45:48 发布

阅读量112

点赞数

分类专栏： JUC 文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_45364328/article/details/124953427

版权

JUC 专栏收录该内容

19 篇文章 1 订阅

订阅专栏

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

之前讲解的 Monitor 主要关注的是访问共享变量时，保证临界区代码的原子性
这一章我们进一步深入学习共享变量在多线程间的【可见性】问题与多条指令执行时的【有序性】问题

Java 内存模型

JMM 即 Java Memory Model，它定义了主存、工作内存抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、CPU 指令优化等。

JMM 体现在以下几个方面：

原子性 - 保证指令不会受到线程上下文切换的影响
可见性 - 保证指令不会受 cpu 缓存的影响
有序性 - 保证指令不会受 cpu 指令并行优化的影响

可见性

退不出的循环

先来看一个现象，main 线程对 run 变量的修改对于 t 线程不可见，导致了 t 线程无法停止：

public class Test31 {
    static boolean run = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(run){
                // ....
            }
        });
        t.start();
        Thread.sleep(1000);
        run = false; // 线程t不会如预想的停下来
    }
}

在这里插入图片描述
为什么呢？分析一下：

初始状态， t 线程刚开始从主内存读取了 run 的值到工作内存。
因为 t 线程要频繁从主内存中读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高速缓存中，减少对主存中 run 的访问，提高效率
1 秒之后，main 线程修改了 run 的值，并同步至主存，而 t 是从自己工作内存中的高速缓存中读取这个变量的值，结果永远是旧值

解决方法

1、volatile（易变关键字）

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

public class Test31 {
    static volatile  boolean run = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(run){
                // ....
            }
        });
        t.start();
        Thread.sleep(1000);
        run = false; // 线程t不会如预想的停下来
    }
}

在这里插入图片描述
2、sychronized

public class Test31 {
    static boolean run = true;

    final static Object obj = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (true) {
                // ....
                synchronized (obj) {
                    if (!run) {
                        break;
                    }
                }
            }
        });
        t.start();
        Thread.sleep(1000);
        synchronized (obj) {
            run = false; // 线程t不会如预想的停下来
        }
    }
}

sychronized也能改变共享变量的可见性，但是它与volatile还是有区别的，sychronized要创建Monitor，比较重，volatile更轻量，在解决可见性上，推荐使用volatile。
sychronized可以保证可见性、原子性、有序性
Monitor只能保证可见性和有序性，不能保证原子性，也就说不能解决指令交错的问题，后面会详细说

可见性和原子性

前面例子体现的实际就是可见性，它保证的是在多个线程之间，一个线程对 volatile 变量的修改对另一个线程可见，不能保证原子性，仅用在一个写线程，多个读线程的情况：上例从字节码理解是这样的：

getstatic run // 线程 t 获取 run true 
getstatic run // 线程 t 获取 run true 
getstatic run // 线程 t 获取 run true 
getstatic run // 线程 t 获取 run true 
putstatic run // 线程 main 修改 run 为 false， 仅此一次
getstatic run // 线程 t 获取 run false

比较一下之前我们将线程安全时举的例子：两个线程一个 i++ 一个 i-- ，只能保证看到最新值，不能解决指令交错：

// 假设i的初始值为0 
getstatic i // 线程2-获取静态变量i的值 线程内i=0 
getstatic i // 线程1-获取静态变量i的值 线程内i=0 
iconst_1 // 线程1-准备常量1 
iadd // 线程1-自增 线程内i=1 
putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1 
iconst_1 // 线程2-准备常量1 
isub // 线程2-自减 线程内i=-1 
putstatic i // 线程2-将修改后的值存入静态变量i 静态变量i=-1

注意 synchronized 语句块既可以保证代码块的原子性，也同时保证代码块内变量的可见性。但缺点是
synchronized 是属于重量级操作，性能相对更低
如果在前面示例的死循环中加入 System.out.println() 会发现即使不加 volatile 修饰符，线程 t 也能正确看到对 run 变量的修改了，想一想为什么？

public class Test31 {
    static  boolean run = true;

    final  static Object obj = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(run){
                System.out.println();
                // ....
            }
        });
        t.start();
        Thread.sleep(1000);
        run = false; // 线程t不会如预想的停下来
    }
}






 public void println() {
        newLine();
    }
 private void newLine() {
        try {
            synchronized (this) {
                ensureOpen();
                textOut.newLine();
                textOut.flushBuffer();
                charOut.flushBuffer();
                if (autoFlush)
                    out.flush();
            }
        }
        catch (InterruptedIOException x) {
            Thread.currentThread().interrupt();
        }
        catch (IOException x) {
            trouble = true;
        }
    }

用volatile实现我们之前说的两阶段终止模式

@Slf4j(topic = "c.Test10")
public class Test10 {

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

        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.start();
        Thread.sleep(3500);
        tpt.stop();
    }
}

@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination {
    private Thread monitor;
   
    
    private volatile  Boolean stop=false;
    //启动监控线程

    public void start() {

        monitor = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    Thread thread = Thread.currentThread();
                    if (stop){
                        log.debug("料理后事");
                        break;
                    }

                    try {
                        Thread.sleep(1000);
                        log.debug("执行监控记录");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        monitor.start();

    }
    public void stop() {
        stop=true;
        monitor.interrupt(); //这个还是要保留，解决阻塞状态的退出
    }

}

同步模式 Balking

Balking（犹豫）用在一个线程发现另一件线程或者本线程已经做了某一件相同的事，那么本线程就无需要再做了，直接结束返回

我们先看下面这段代码：启动了三个监控线程，但是一般监控线程只有一个就行，我们怎么解决多次调用start时，只启动一个线程呢？

@Slf4j(topic = "c.Test10")
public class Test10 {

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

        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.start();
        tpt.start();
        tpt.start();
    }
    
}

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


    private volatile  Boolean stop=false;
    //启动监控线程

    public void start() {
        monitor = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    Thread thread = Thread.currentThread();
                    if (stop){
                        log.debug("料理后事");
                        break;
                    }

                    try {
                        Thread.sleep(1000);
                        log.debug("执行监控记录");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        monitor.start();
    }


    public void stop() {
        stop=true;
        monitor.interrupt(); //这个还是要保留，解决阻塞状态的退出
    }

}

20:32:35.124 [Thread-2] DEBUG c.TwoPhaseTermination - 执行监控记录
20:32:35.125 [Thread-0] DEBUG c.TwoPhaseTermination - 执行监控记录
20:32:35.124 [Thread-1] DEBUG c.TwoPhaseTermination - 执行监控记录

Balking模式解决上面问题

例子：在这里插入代码片

@Slf4j(topic = "c.MonitorService")
public class MonitorService {
    
    private volatile boolean starting;
    
    public void start(){
        log.info("尝试启动监控线程");
        synchronized (this){
            if(starting){
                return;
            }
            //执行业务逻辑
            starting =true;
        }
    }
}

当前端页面多次点击按钮调用start时，只执行一次业务逻辑

因此上面的代码可以这么写：

@Slf4j(topic = "c.Test10")
public class Test10 {

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

        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.start();
        tpt.start();
        tpt.start();
    }

}

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


    private volatile  Boolean stop=false;

    //是否执行过监控
    private volatile  boolean starting =false;
    //启动监控线程
    public void start() {
        synchronized (this){
            if (starting){
                return;
            }
        }
        starting=true;
        monitor = new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    Thread thread = Thread.currentThread();
                    if (stop){
                        log.debug("料理后事");
                        break;
                    }

                    try {
                        Thread.sleep(1000);
                        log.debug("执行监控记录");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        monitor.start();
    }


    public void stop() {
        stop=true;
        monitor.interrupt(); //这个还是要保留，解决阻塞状态的退出
    }

}

Balking常用来实现单例模式：

public class Singleton {
    public Singleton(){
        
    }
   
    private static Singleton INSTANCE = null;
    
    public static synchronized Singleton getInstance(){
        if (INSTANCE!=null){
            return INSTANCE;
        }
        INSTANCE = new Singleton();
        return INSTANCE;
    }
}

对比一下保护性暂停模式：保护性暂停模式用于一个线程等待另一个线程的执行成果，当条件不满足时线程等待。

有序性

JVM 会在不影响正确性的前提下，可以调整语句的执行顺序，思考下面一段代码

static int i;
static int j;
// 在某个线程内执行如下赋值操作
i = ...; 
j = ...;

可以看到，至于是先执行 i 还是先执行 j ，对最终的结果不会产生影响。所以，上面代码真正执行时，既可以是：

i = ...; 
j = ...;

也可以是

j = ...;
i = ...;

这种特性称之为『指令重排』，多线程下『指令重排』会影响正确性。为什么要有重排指令这项优化呢？从 CPU执行指令的原理来理解一下吧

鱼罐头的故事

在这里插入图片描述

诡异的结果

int num = 0;
    boolean ready = false;
    // 线程1 执行此方法
    public void actor1(I_Result r) {
        if(ready) {
            r.r1 = num + num;
        } else {
            r.r1 = 1;
        }
    }
    // 线程2 执行此方法
    public void actor2(I_Result r) {
        num = 2;
        ready = true;
    }

I_Result 是一个对象，有一个属性 r1 用来保存结果，问，可能的结果有几种？
有同学这么分析
情况1：线程1 先执行，这时 ready = false，所以进入 else 分支结果为 1
情况2：线程2 先执行 num = 2，但没来得及执行 ready = true，线程1 执行，还是进入 else 分支，结果为1
情况3：线程2 执行到 ready = true，线程1 执行，这回进入 if 分支，结果为 4（因为 num 已经执行过了）
但我告诉你，结果还有可能是 0 😁😁😁，信不信吧！
这种情况下是：线程2 执行 ready = true，切换到线程1，进入 if 分支，相加为 0，再切回线程2 执行 num = 2
相信很多人已经晕了 😵😵😵
这种现象叫做指令重排，是 JIT 编译器在运行时的一些优化，这个现象需要通过大量测试才能复现：
借助 java 并发压测工具 jcstress https://wiki.openjdk.java.net/display/CodeTools/jcstress

mvn archetype:generate -DinteractiveMode=false -DarchetypeGroupId=org.openjdk.jcstress -
DarchetypeArtifactId=jcstress-java-test-archetype -DarchetypeVersion=0.5 -DgroupId=cn.itcast -
DartifactId=ordering -Dversion=1.0

创建 maven 项目，提供如下测试类

@JCStressTest
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "ok")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "!!!!")
@State
public class ConcurrencyTest {
    int num = 0;
    boolean ready = false;
    @Actor
    public void actor1(I_Result r) {
        if(ready) {
            r.r1 = num + num;
        } else {
            r.r1 = 1;
        }
    }
    @Actor
    public void actor2(I_Result r) {
        num = 2;
        ready = true;
    }
}

执行

mvn clean install 
java -jar target/jcstress.jar

会输出我们感兴趣的结果，摘录其中一次结果：

在这里插入图片描述

可以看到，出现结果为 0 的情况有 638 次，虽然次数相对很少，但毕竟是出现了。

解决方法

volatile 修饰的变量，可以禁用指令重排

@JCStressTest
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "ok")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "!!!!")
@State
public class ConcurrencyTest {
    int num = 0;
    volatile boolean ready = false;
    @Actor
    public void actor1(I_Result r) {
        if(ready) {
            r.r1 = num + num;
        } else {
            r.r1 = 1;
        }
    }
    @Actor
    public void actor2(I_Result r) {
        num = 2;
        ready = true;
    }
}

结果为
在这里插入图片描述

volatile原理

volatile的底层实现时内存屏障，Memory Barrier（Memory Fence）

对volatile变量的写指令后会加入写屏障
对volatile变量的读指令前会加入读屏障

如何保证可见性

在这里插入图片描述

如何保证有序性

在这里插入图片描述

doubled-checked locking 问题

在这里插入图片描述

我们尝试对上述代码改进
在这里插入图片描述
这段代码看似很完美，但实际上是存在问题的，因为sychronized只保证其内部的代码时原子有序的

在这里插入图片描述

sychronized解决有序性问题上和volite不同，volite不让指令重排发生，但是sychronized块内是可以指令重排的，因此，在多线程下想要保证安全性，sychronized就得把共享变量全包住

doubled-checked locking 解决

在这里插入图片描述

happens-before

happens-before 规定了对共享变量的写操作对其它线程的读操作可见，它是可见性与有序性的一套规则总结，抛开以下 happens-before 规则，JMM 并不能保证一个线程对共享变量的写，对于其它线程对该共享变量的读可见

线程解锁 m 之前对变量的写，对于接下来对 m 加锁的其它线程对该变量的读可见

static int x;
    static Object m=new Object();
        new Thread(()->{
        synchronized(m){
            x=10;
        }
    },"t1").start();
        new Thread(()->{
        synchronized(m){
            System.out.println(x);
        }
    },"t2").start();

线程对 volatile 变量的写，对接下来其它线程对该变量的读可见

volatile static int x;
new Thread(()->{
        x = 10;
    },"t1").start();
new Thread(()->{
        System.out.println(x);
    },"t2").start();

线程 start 前对变量的写，对该线程开始后对该变量的读可见

static int x; x = 10;
new Thread(()->{
 System.out.println(x);
},"t2").start();

线程结束前对变量的写，对其它线程得知它结束后的读可见（比如其它线程调用 t1.isAlive() 或 t1.join()等待
它结束）

static int x;
Thread t1 = new Thread(()->{
 x = 10;
},"t1");
t1.start();
t1.join();
System.out.println(x);

线程 t1 打断 t2（interrupt）前对变量的写，对于其他线程得知 t2 被打断后对变量的读可见（通过t2.interrupted 或 t2.isInterrupted）

 static int x;
    public static void main(String[] args) {
        Thread t2 = new Thread(()->{
            while(true) {
                if(Thread.currentThread().isInterrupted()) {
                    System.out.println(x);
                    break;
                }
            }
        },"t2");
        t2.start();
        new Thread(()->{
            sleep(1);
            x = 10;
            t2.interrupt();
        },"t1").start();
        while(!t2.isInterrupted()) {
            Thread.yield();
        }
        System.out.println(x);
    }

对变量默认值（0，false，null）的写，对其它线程对该变量的读可见
具有传递性，如果 x hb-> y 并且 y hb-> z 那么有 x hb-> z ，配合 volatile 的防指令重排，有下面的例子

volatile static int x;
static int y;
new Thread(()->{ 
 y = 10;
 x = 20;
},"t1").start();
new Thread(()->{
 // x=20 对 t2 可见, 同时 y=10 也对 t2 可见
 System.out.println(x); 
},"t2").start()

变量都是指成员变量或静态成员变量

习题

balking 模式习题

希望 doInit() 方法仅被调用一次，下面的实现是否有问题，为什么？

 public class TestVolatile {
        volatile boolean initialized = false;
        void init() {
            if (initialized) {
                return;
            }
            doInit();
            initialized = true;
        }
        private void doInit() {
        }
    }

initialized 变量被volatile ，修饰保证了可见性，但是不能保证原子性，在多线程下，init可能会被调用多次

线程安全单例习题

单例模式有很多实现方法，饿汉、懒汉、静态内部类、枚举类，试分析每种实现下获取单例对象（即调用getInstance）时的线程安全，并思考注释中的问题

饿汉式：类加载就会导致该单实例对象被创建
懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

实现1：

// 问题1：为什么加 final         答：怕有子类重写方法破坏单例
// 问题2：如果实现了序列化接口, 还要做什么来防止反序列化破坏单例    答： readResolve()  
public final class Singleton implements Serializable {
    // 问题3：为什么设置为私有? 答：防止别的类创建对象 是否能防止反射创建新的实例?  答：不能，暴力反射
    private Singleton() {}
    // 问题4：这样初始化是否能保证单例对象创建时的线程安全?   答：能，静态成员标量在类加载的时候完成，由JVM保证安全性
    private static final Singleton INSTANCE = new Singleton();
    // 问题5：为什么提供静态方法而不是直接将 INSTANCE 设置为 public, 说出你知道的理由  
     答：用方法可以实现更好的封装性，更适合改为懒惰式，还可以提供泛型的支持
    public static Singleton getInstance() {
        return INSTANCE;
    }
    public Object readResolve() {
        return INSTANCE;
    }
}

实现2：

// 问题1：枚举单例是如何限制实例个数的
答：反编译后可以看到 就是我们枚举类的一个静态成员变量而已，单实例的

// 问题2：枚举单例在创建时是否有并发问题
答：没有，类加载的时候创建
// 问题3：枚举单例能否被反射破坏单例
答：不能
// 问题4：枚举单例能否被反序列化破坏单例
答：不能
// 问题5：枚举单例属于懒汉式还是饿汉式
答：饿汉式，一加载就创建
// 问题6：枚举单例如果希望加入一些单例创建时的初始化逻辑该如何做
答：在内部加构造方法

enum Singleton { 
 INSTANCE; 
}

问题1在这里插入代码片
在这里插入图片描述
问题6：

class Resource{
}

public enum SomeThing {
    INSTANCE;
    private Resource instance;
    SomeThing() {
        instance = new Resource();
    }
    public Resource getInstance() {
        return instance;
    }
}

上面的类Resource是我们要应用单例模式的资源，具体可以表现为网络连接，数据库连接，线程池等等。获取资源的方式很简单，只要 SomeThing.INSTANCE.getInstance() 即可获得所要实例

实现3：

 public final class Singleton {
        private Singleton() { }
        private static Singleton INSTANCE = null;
        // 分析这里的线程安全, 并说明有什么缺点
        可以保证线程安全，但是这里每次getInstance都会上锁
        public static synchronized Singleton getInstance() {
            if( INSTANCE != null ){
                return INSTANCE;
            }
            INSTANCE = new Singleton();
            return INSTANCE;
        }
    }

实现4：

 public final class Singleton {
        private Singleton() { }
        // 问题1：解释为什么要加 volatile ?   可见性
        private static volatile Singleton INSTANCE = null;

        // 问题2：对比实现3, 说出这样做的意义  ：防止多次调用getInstance时都synchronized 
        public static Singleton getInstance() {
            if (INSTANCE != null) {
                return INSTANCE;
            }
            synchronized (Singleton.class) {
                // 问题3：为什么还要在这里加为空判断, 之前不是判断过了吗
                解决第一次调用getInstance时，多线程的并发问题，否则会创建多次INSTANCE
                if (INSTANCE != null) { // t2 
                    return INSTANCE;
                }
                INSTANCE = new Singleton();
                return INSTANCE;
            }
        }
    }

实现5：

public final class Singleton {
    private Singleton() { }
    // 问题1：属于懒汉式还是饿汉式     懒汉式（第一次加载类时才创建，这个类加载本身就是懒惰的）
    private static class LazyHolder {
        static final Singleton INSTANCE = new Singleton();
    }
    // 问题2：在创建时是否有并发问题   没有   INSTANCE只有一份
    public static Singleton getInstance() {
        return LazyHolder.INSTANCE;
    }
}

香树

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
7、共享模型之内存（可见性、原子性、有序性；volatie原理以及使用案例、happens-before）

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言Java 内存模型可见性退不出的循环解决方法可见性和原子性用volatile实现我们之前说的两阶段终止模式同步模式 Balking有序性鱼罐头的故事诡异的结果解决方法volatile原理如何保证可见性如何保证有序性doubled-checked locking 问题doubled-checked locking 解决happens-before习题balking 模式习题线程安全单例习题前言之前讲解的 Monitor 主.
复制链接

扫一扫