【记录】并发编程 - 学习日志（五）

已于 2023-09-20 14:31:50 修改
阅读量50 收藏
点赞数
分类专栏： 并发编程 - 学习日志 文章标签： 学习 java 开发语言
于 2023-09-16 16:20:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73376124/article/details/132906418
版权
本文详细探讨了Java内存模型中的可见性问题，重点介绍了volatile关键字和synchronized在保证线程安全中的作用，以及两阶段终止模式、犹豫模式和内存屏障的概念，解释了指令重排对多线程一致性的影响。
摘要由CSDN通过智能技术生成

5. 共享模型之内存

5.1 Java 内存模型

java 内存模型，简称 JMM，包括主存（线程共享）和工作内存（线程私有）

5.2 可见性

package com.rui.jmm;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test1")
public class Test1 {
    static Boolean run = true;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (run) {

            }
        }, "t").start();

        Thread.sleep(1000);
        run = false;
        log.debug("run = {}", run);
    }
}

// 某次运行结果

16:12:03 [main] c.Test1 - run = false

为何在主线程中将 run 的值修改为 false 后，t 线程并未运行结束？

1. t 线程读取主存中 run 的值到其工作内存中；

2. 因 t 线程频繁向主存中读取 run 的值，故即时编译器（JIT 编译器）会将主存中 run 的值缓存在其工作内存的高速缓存中；

3. t 线程不在向主存中读取 run 的值，转为向即时编译器工作内存的高速缓存中读取 run 的值；

4. 1 秒后，主线程将其工作线程中 run 的值改为 false 并同步到主存中，但因【3】，故 t 线程未运行结束。

那么该如何解决上述问题呢？

这里提供两种解决方法。

volatile

package com.rui.jmm;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test1")
public class Test1 {
    static volatile Boolean run = true;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            while (run) {

            }
        }, "t").start();

        Thread.sleep(1000);
        run = false;
        log.debug("run = {}", run);
    }
}

// 运行结果

16:43:19 [main] c.Test1 - run = false

进程已结束，退出代码 0

使用 volatile 关键字修饰成员变量和类变量（静态变量）可强制线程仅能从主存中读取变量的值

volatile 关键字可以用来修饰局部变量吗？

因局部变量存储在工作内存中，故而无需从主存中读取，也就无需被 volatile 关键字修饰了。

局部变量存储在 JVM - 运行时数据区 - Java 虚拟机栈 - 栈帧 - 局部变量表中，属线程私有。

synchronized 

package com.rui.jmm;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test2")
public class Test2 {
    static Boolean run = true;
    static Object o = new Object();

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> {
            synchronized (o) {
                while (true) {
                    if (!run) {
                        break;
                    }
                }
            }
        }, "t").start();

        synchronized (o) {
            Thread.sleep(1000);
            run = false;
            log.debug("run = {}", run);
        }

    }
}

// 运行结果

16:54:24 [main] c.Test2 - run = false

进程已结束，退出代码 0

volatile 和 synchronized 两种解决方法的区别

volatilesynchronized
可见性√√
原子性×√
较轻量级重量级

5.3 两阶段终止模式

package com.rui.jmm;

import lombok.extern.slf4j.Slf4j;

public class Test4 {
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.start();
        Thread.sleep(5000);
        tpt.end();
    }
}

@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination {
    private Thread t1;
    private volatile Boolean stop = false;

    public void start() {
        t1 = new Thread("t1") {
            @Override
            public void run() {
                while (true) {
                    if (stop) {
                        log.debug("料理后事");
                        break;
                    }
                    try {
                        Thread.sleep(1000);
                        log.debug("无异常，执行监控记录");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t1.start();
    }

    public void end() {
        stop = true;
        t1.interrupt();
    }
}

// 某次运行结果

18:35:20 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
18:35:21 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
18:35:22 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
18:35:24 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at com.rui.jmm.TwoPhaseTermination$1.run(Test4.java:29)
18:35:24 [t1] c.TwoPhaseTermination - 料理后事

进程已结束，退出代码 0

 5.4 犹豫模式（Balking）

package com.rui.jmm;

import lombok.extern.slf4j.Slf4j;

public class Test5 {
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination5 tpt = new TwoPhaseTermination5();
        tpt.start();
        tpt.start();
        tpt.start();
        Thread.sleep(5000);
        tpt.end();
    }
}

@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination5 {
    private Thread t1;
    private volatile Boolean stop = false;

    public void start() {
        t1 = new Thread("t1") {
            @Override
            public void run() {
                while (true) {
                    if (stop) {
                        log.debug("料理后事");
                        break;
                    }
                    try {
                        Thread.sleep(1000);
                        log.debug("无异常，执行监控记录");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t1.start();
    }

    public void end() {
        stop = true;
        t1.interrupt();
    }
}

// 某次运行结果

18:52:51 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
18:52:51 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
18:52:51 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
18:52:52 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
18:52:52 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
18:52:52 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
18:52:53 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
18:52:53 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
18:52:53 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
18:52:54 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
18:52:54 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
18:52:54 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at com.rui.jmm.TwoPhaseTermination5$1.run(Test5.java:31)
18:52:55 [t1] c.TwoPhaseTermination - 料理后事
18:52:55 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
18:52:55 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
18:52:55 [t1] c.TwoPhaseTermination - 料理后事
18:52:55 [t1] c.TwoPhaseTermination - 料理后事

如何避免同一时间同一线程多次启动呢？

package com.rui.jmm;

import lombok.extern.slf4j.Slf4j;

public class Test5 {
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination5 tpt = new TwoPhaseTermination5();
        tpt.start();
        tpt.start();
        tpt.start();
        Thread.sleep(5000);
        tpt.end();
    }
}

@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination5 {
    private Thread t1;
    private volatile Boolean stop = false;
    private Boolean starting = false;

    public void start() {
        t1 = new Thread("t1") {
            @Override
            public void run() {
                synchronized (this) {
                    if (starting) {
                        return;
                    }
                    starting = true;
                }
                while (true) {
                    if (stop) {
                        log.debug("料理后事");
                        break;
                    }
                    try {
                        Thread.sleep(1000);
                        log.debug("无异常，执行监控记录");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t1.start();
    }

    public void end() {
        stop = true;
        t1.interrupt();
    }
}

// 某次运行结果

19:04:21 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
19:04:22 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
19:04:23 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
19:04:24 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
19:04:25 [t1] c.TwoPhaseTermination - 无异常，执行监控记录
19:04:25 [t1] c.TwoPhaseTermination - 料理后事

进程已结束，退出代码 0

5.5 有序性

指令重排：JVM 会在不影响（单线程）正确性的前提下调整语句的执行顺序

指令重排可能会影响多线程正确性

    // 符合指令重排条件
    int a = 1;
    int b = 2;

    // 不符合指令重排条件
    int c = 3;
    int d = c + 1;

5.6 内存屏障

  • 可见性

        在读屏障之后对共享变量的读取均来自主存

        在写屏障之前对共享变量的修改同步到主存

  • 有序性

        语句的执行顺序：

        读/写屏障之前的语句 -> 读/写屏障之后的语句

5.7 volatile 原理

volatile 的底层原理是 内存屏障

使用 volatile 修饰共享变量后，读取该变量的语句后会设置读屏障，修改该变量的语句前会设置写屏障。

    // 禁止指令重排
    int a = 1;
    volatile int b = 2;

为何仅 b 变量被 volatile 关键字修饰即可禁止指令重排

    // 禁止指令重排
    int a = 1;

    // --- 写屏障 ---
    volatile int b = 2;

double - checked locking（双检索）

以单例模式为例

package com.rui.jmm;

public final class Singleton {

    private Singleton() {
    }

    private static Singleton INSTANCE = null;

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

假设多个线程同时执行 getInstance 方法，那么这些线程皆需获取锁，该如何优化呢？

package com.rui.jmm;

public final class Singleton {
    
    private Singleton() {
    }

    private static Singleton INSTANCE = null;

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

可能先执行 return INSTANCE; 语句（指令重排），如何解决这个问题呢？

package com.rui.jmm;

public final class Singleton {

    private Singleton() {
    }

    private static volatile Singleton INSTANCE = null;

    public static Singleton getInstance() {
        if (INSTANCE == null) {
            synchronized (Singleton.class) {
                if (INSTANCE == null) {
                    //写屏障
                    INSTANCE = new Singleton();
                }
                //读屏障
            }
        }
        // 读屏障
        return INSTANCE;
    }
}

5.8 happens - before

synchronized：线程拥有对象锁时对共享变量的修改 对 该线程释放该对象锁后，其他线程拥有对象锁时对共享变量的读取 可见

package com.rui.jmm;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test6")
public class Test6 {
    static int count = 1;
    static Object o = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            synchronized (o) {
                count = 10;
            }
        }, "t1").start();
        new Thread(() -> {
            synchronized (o) {
                System.out.println(count);
            }
        }, "t2").start();
    }
}

// 运行结果

10

进程已结束，退出代码 0

volatile：使用 volatile 关键字修饰共享变量后，线程对共享变量的修改 对 之后其他线程对共享变量的读取 可见

package com.rui.jmm;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test7")
public class Test7 {
    static volatile int count = 1;

    public static void main(String[] args) {
        new Thread(() -> {
            count = 10;
        }, "t1").start();
        new Thread(() -> {
            System.out.println(count);
        }, "t2").start();
    }
}

// 运行结果

10

进程已结束，退出代码 0

如果对共享变量的修改发生在线程的初始状态，那么该修改 对 就绪状态及其以后的该线程 可见

package com.rui.jmm;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test8")
public class Test8 {
    static int count = 1;

    public static void main(String[] args) {

        count = 5;

        new Thread(() -> {
            System.out.println(count);
        }, "t").start();
    }
}

// 运行结果

5

进程已结束，退出代码 0

终止状态前的线程对共享变量的修改 对 该线程运行结束后，其他线程对共享变量的读取 可见

package com.rui.jmm;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test9")
public class Test9 {
    static int count = 1;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            count = 10;
        }, "t");

        t.start();

        t.join();
        System.out.println(count);
    }
}

// 运行结果

10

进程已结束，退出代码 0

t1 线程打断 t2 线程前对共享变量的修改 对 该修改后，其他线程对共享变量的读取 可见

package com.rui.jmm;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test10")
public class Test10 {
    static int count = 1;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (true) {
                if (Thread.currentThread().isInterrupted()) {
                    break;
                }
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            count = 5;
            t1.interrupt();
        }, "t2");


        t1.start();
        t2.start();

        while (true) {
            if (t1.isInterrupted()) {
                System.out.println(count);
                break;
            }
        }
    }
}

// 运行结果

5

进程已结束，退出代码 0

 对默认初始化的共享变量的修改 对 修改后，线程对共享变量的读取 可见

内存屏障

package com.rui.jmm;

public class Test12 {
    static volatile int x = 1;
    static int y = 5;

    public static void main(String[] args) {
        new Thread(() -> {
            y = 1;
            x = 5;
        }).start();

        new Thread(() -> {
            System.out.println("x = " + x);
            System.out.println("y = " + y);
        }).start();
    }
}

// 运行结果

x = 5
y = 1

进程已结束，退出代码 0

说些废话

本篇文章为博主日常学习记录，故而会小概率存在各种错误，若您在浏览过程中发现一些，请在评论区指正，望我们共同进步，谢谢！

在听Rr.
关注
专栏目录
java并发编程-超级大全整理
10-19
【Java 并发编程-超级大全整理】 Java 并发编程是Java开发中不可或缺的一部分，尤其是在高并发场景下，能够有效提升程序的运行效率。本文将深入探讨Java多线程的相关知识点，帮助开发者理解并掌握如何在Java环境中...
商业编程-源码-MyLog 小鱼日志 v1.1.zip
06-21
4. **异步处理**：在高并发环境下，日志记录应采用异步方式，避免阻塞主线程。 5. **日志切割**：为了避免单个日志文件过大，系统可能会定时或按大小切割日志文件。 6. **日志过滤**：通过配置，允许用户只记录...
商业编程-源码-Dday个人日志系统 v1.0 多用户版.zip
06-21
《Dday个人日志系统 v1.0 多用户版》是一个专为商业编程环境设计的源码项目，它提供了一种高效、安全且多用户兼容的日志管理解决方案。这个系统的核心目标是帮助用户在日常工作中跟踪、记录并管理他们的个人活动和...
Java并发编程-线程安全与基础构建模块
04-04
2. **守护线程（Daemon Thread）**：后台运行的线程，当所有非守护线程结束时，程序会自动停止，常用于日志记录、垃圾收集等任务。 3. **线程通信**：`wait()`、`notify()`和`notifyAll()`方法用于线程间的协作，...
商业编程-源码-通用的应用程序高级日志系统.zip
06-23
在IT行业中，日志系统是不可或缺的一部分，尤其在商业编程领域。它对于应用程序的调试、性能分析、故障排查以及安全监控至关重要。这个“通用的应用程序高级日志系统”压缩包包含的源码很可能是用于创建一个高效且可...
shader 案例学习笔记之将坐标系分成4个象限
localhost
09-13 102
坐标系被分成了4个单元格，每个单元格都有唯一的索引，后续就可以根据索引去渲染。
UEFI学习笔记（五）：EDK II PCD的概念、类型、使用
qq_44189622的博客
09-11 790
如果在BIOS里面有一些模块是binary方式集成进来的而这些binary又需要用到PCD（用于Binary Release），那么这些Binary集成的要用到的PCD就必须要设置为。PCD的值存在memory里面，下次启动时，上次更改的值丢失了，每次启动都是从default值开始。是存在VPD空间的（在FLASH上，只读），一般是出厂配置。如果platform是从源码build出来的，没有binary在里面的时候，PCD用的都是。作用域在一个模块中（模块级的），可以在Binary Level进行修改。
Redis 入门 - 五大基础类型及其指令学习
IT规划师
09-11 695
学习Redis基础类型：字符串、集合、有序集合、列表、哈希，每种类型有各自的特点和常用指令。掌握这些基础是熟练使用Redis的关键。更多指令需自行尝试。
Spring Framework 学习总结博客
最新发布
2302_80084329的博客
09-13 663
通过本文的学习，我们从Spring的核心架构入手，逐步理解了IoC和DI的概念，并通过代码示例掌握了如何在实际项目中使用这些技术。Spring通过IoC容器管理bean，依赖注入将bean之间的关系解耦，大大简化了复杂系统的开发过程。这些基本的Spring知识是理解其高级特性（如AOP、事务管理）的基础，掌握这些概念后，我们可以更加自如地使用Spring构建复杂的企业级应用。
计算几何学习
网安小白
09-12 344
学习计算几何过程中对经典算法的记录
sheng的学习笔记-AI-规则学习（rule learning）
coldstarry的专栏
09-09 1147
机器学习中的“规则”(rule)通常是指语义明确、能描述数据分布所隐含的客观规律或领域概念、可写成“若……，则……”形式的逻辑规则。​“规则学习”(rule learning)是从训练数据中学习出一组能用于对未见示例进行判别的规则。一条规则形如：在数理逻辑中“文字”专指原子公式(atom)及其否定。与神经网络、支持向量机这样的“黑箱模型”相比，规则学习具有更好的可解释性，能使用户更直观地对判别过程有所了解。另一方面，数理逻辑具有极强的表达能力，绝大多数人类知识都能通过数理逻辑进行简洁的刻画和表达。
AdaBoost算法（AdbBoost Algorithm）—有监督学习方法、非概率模型、判别模型、非线性模型、非参数化模型、批量学习
nanxiaotao的博客
09-11 838
AdaBoost算法（AdbBoost Algorithm）—有监督学习方法、非概率模型、判别模型、非线性模型、非参数化模型、批量学习
Android Fragment 学习备忘
sdaujz的博客
09-08 411
1.fragment的动态添加与管理：
【学习笔记】SSL证书之前向保密
Taki_UP的博客
09-10 689
本篇介绍了密码学中前向保密（Forward Secrecy）的相关内容
IIC基本学习
????????????????????????????????????????????????
09-11 220
对IIC通信协议补充了基本的了解，在进行相关的工程实践后再进行补充。
《数字信号处理》学习05-单位冲击响应与系统响应
码到成龚的博客
09-08 1234
一，单位冲激响应二，LTI系统对任意序列的系统响应三，LTI系统的性质​ 在《信号与系统》中，离散时间线性时不变系统用 唯一表征： ：单位冲击响应（或称为单位抽样响应）。输入序列是单位冲击序列，输出序列是初始状态为0时系统的输出。 1，h虽然不是特定单词的缩写，但在信号处理领域的使用已经成为一种约定，代表了系统的单位冲击响应，因此，一般用来代表离散时间LTI系统的单位冲击响应。 2，之所以强调输出序列是在初始状态为0时的系统输出，是因为在“初始状态为0”时输出序列完全基于输入序列和单
学习Linux用户和用户组管理的常用命令
weixin_74075792的博客
09-12 306
通过以上学习目标的实现，用户应能够理解和掌握Linux系统中用户和用户组的概念及其管理方法，并能熟练运用相关命令进行操作。这些知识对Linux系统的日常管理和维护至关重要，特别是在多用户多任务环境中。
通信工程学习：什么是GFP通用成帧规范
limengshi138392的博客
09-12 738
通信工程学习：什么是GFP通用成帧规范
通信工程学习：什么是PDF策略决策功能
limengshi138392的博客
09-12 853
通信工程学习：什么是PDF策略决策功能
Java并发编程：线程信息获取与设置实战
线程名则可以通过`Thread.getName()`获取或通过`Thread.setName()`设置，这对于调试和日志记录非常有用。线程的优先级是通过`Thread.getPriority()`和`Thread.setPriority()`进行读取和设置的，不过通常不建议直接...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值