并发编程：（四）共享模型之内存

最新推荐文章于 2024-08-20 09:22:36 发布
最新推荐文章于 2024-08-20 09:22:36 发布
阅读量351 收藏 1
点赞数
分类专栏： 多线程与并发 文章标签： 多线程
余笙
本文链接：https://blog.csdn.net/qq_42200163/article/details/107543486
版权

一、Java内存模型

1、前言

Monitor 主要关注的是访问共享变量时，保证临界区代码的原子性。

2、定义

JMM 即 Java Memory Model，它定义了主存（所有线程共享的数据存放位置）、工作内存（每个线程私有的数据存放位置）抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、CPU 指令优化等。

JMM 体现在以下几个方面：

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

3、可见性（volatile）

public class Test05 {
    static boolean run = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (run) {
                // ....
            }
        });
        t.start();

        sleep(1000);
        run = false;//线程t1不会如预想的停下来
    }
}

分析：

  1. 初始状态，t 线程 刚开始从主内存读取了 run 的值到工作内存。

在这里插入图片描述

  1. 因为 t线程 需要频繁从主内存中读取 run 的值，JIT编译器 会将 run 的值缓存至自己工作内存中的高速缓存中，减少对主存中 run 的访问，提高效率。

在这里插入图片描述

  1. 1秒之后，main 线程修改了 run 的值，并同步至主内存，而 t线程 是从自己工作内存中的高速缓存中读取 run这个变量的值，结果永远是之前的值（true）。

在这里插入图片描述

解决办法：

volatile 关键字

  • 可以用来修饰成员变量和静态成员变量，保证线程间变量的可见性，但不能保证原子性。
  • 线程对变量进行修改后，要立刻写回主内存中。线程操作 volatile 变量都是直接操作主存。
  • 线程对变量读取的时候，必须到主内存中读取变量的值，而不是缓存中。
public class Test05 {
    volatile  static boolean run = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            while (run) {
                // ....
            }
        });
        t1.start();

        sleep(1000);
        run = false;//线程t1会停止
    }
}

使用 synchronized 也能达到预期效果

public class Test05 {
    final static Object obj = new Object();
    static boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(()->{
            while (flag) {
                synchronized (obj) {
                    if (!flag) {
                        break;
                    }
                }
            }
        });
        t1.start();

        sleep(1000);
        synchronized (obj){
            flag = false;
        }
    }
}

4、原子性

原子是世界上的最小单位，具有不可分割性。比如 a = 0；（a非long和double类型） 这个操作是不可分割的，那么我们说这个操作是原子操作。再比如 a++； 这个操作实际是a = a + 1；是可分割的，所以他不是一个原子操作。非原子操作都会存在线程安全问题，需要我们使用同步技术（sychronized）来让它变成一个原子操作。一个操作是原子操作，那么我们称它具有原子性。

5、可见性 vs 原子性

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

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

注意：

synchronized 语句块既可以保证代码块的原子性，也同时保证代码块内变量的可见性。但缺点是 synchronized 是属于重量级操作，性能相对更低 。

如果在前面示例的死循环中加入 System.out.println() 会发现即使不加 volatile 修饰符，线程 t 也能正确看到 对 run 变量的修改了，查看 println 源码即可知道原因。

6、利用volatile改进两阶段终止模式

两阶段终止模式详见 并发编程（二）

public class Test06 {
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.startMonitor();
        Thread.sleep(3500);
        System.out.println(new Date() + "【"+ Thread.currentThread().getName() + "】 - stop");
        tpt.stopMonitor();
    }
}
//监控类
class TwoPhaseTermination{
    //监控线程
    private Thread monitor;
    //停止标记
    private volatile boolean stop = false;
    //启动监控线程
    public void startMonitor(){
        monitor = new Thread(()->{
            //循环监控
            while (true) {
                //获取当前线程
                Thread current = Thread.currentThread();
                //为true终止循环
                if (stop) {
                    System.out.println(new Date() + "【"+ Thread.currentThread().getName() + "】 - 料理后事...");
                    break;
                }
                try {
                    Thread.sleep(1000); //情况1
                    System.out.println(new Date() + "【"+ Thread.currentThread().getName() + "】 - 执行监控记录"); //情况2
                } catch (InterruptedException e) {
                }
            }
        },"监控线程");
        //启动线程
        monitor.start();
    }

    //停止监控线程
    public void stopMonitor(){
        stop = true;
        monitor.interrupt();//打断sleep
    }
}

7、同步模式之Balking

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

当多次调用 startMonitor() 时，保证只有一个监控线程启动

public class Test06 {
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.startMonitor();
        tpt.startMonitor();
    }
}
//监控类
class TwoPhaseTermination{
    //监控线程
    private Thread monitor;
    //停止标记
    private volatile boolean stop = false;
    //判断是否执行过startMonitor方法
    private boolean starting = false;
    //启动监控线程
    public void startMonitor(){
        //保证每次只有一个监控线程启动
        synchronized (this) {
            if (starting) {
                return;
            }
            starting = true;
        }
        monitor = new Thread(() -> {
            //循环监控
            while (true) {
                //获取当前线程
                Thread current = Thread.currentThread();
                //为true终止循环
                if (stop) {
                    System.out.println(new Date() + "【" + Thread.currentThread().getName() + "】 - 料理后事...");
                    break;
                }
                try {
                    Thread.sleep(1000); //情况1
                    System.out.println(new Date() + "【" + Thread.currentThread().getName() + "】 - 执行监控记录"); //情况2
                } catch (InterruptedException e) {
                }
            }
        }, "监控线程");
        //启动线程
        monitor.start();
    }

    //停止监控线程
    public void stopMonitor(){
        stop = true;
        monitor.interrupt();//打断sleep
    }
}

实现线程安全的单例模式（懒汉式）

public class Singleton {
    //构造私有
    private Singleton(){ }
	//私有的静态属性
    private static Singleton Instance = null;
	//公共的静态方法
    public static synchronized Singleton getInstance(){
        if (Instance != null){
            return Instance;
        }
        Instance = new Singleton();
        return Instance;
    }
}

8、有序性（指令重排）

JVM 会在不影响正确性的前提下，可以调整语句的执行顺序。

static int i;
static int j;
//在某个线程中进行赋值操作
i = ...;
j = ...;
//无论先执行 i 或 j，对最终的结果不会产生影响
//既可以
i = ...;
j = ...;
//也可以是
j = ...;
i = ...;

这种特征称之为【指令重排】，多线程下指令重排会影响正确性。

诡异的结果

int num = 0;
boolean ready = false;

//线程1执行此方法
public void actor1(User u){
    if(ready){
      	u.age = num + num;
    }else{
      	u.age = 1;
    }
}

//线程2执行此方法
public void actor2(User u){
  	num = 2;
  	ready = true; //此处可能会发生指令重排序，可能先执行num=2也可能先执行ready=true
}

User 是一个对象，有一个属性 age 用来保存结果，可能会出现的几种情况：

  1. 情况1：线程1先执行，这时 ready = false，所以进 else 分支结果为1。
  2. 情况2：线程2先执行 num = 2，但没有来得及执行 ready = true，线程1执行，还是进else分支，结果为1。
  3. 情况3：线程2先执行 num = 2，执行 ready = true，线程1执行，进 if 分支结果为4。
  4. 情况4：线程2先执行 ready = true，切换到线程1，进入 if 分支，相加结果为0，再回线程2执行 num = 2。

这种现象叫做指令重排，是 JIT 编辑器在运行时的一些优化，这个现象需要通过大量测试才能复现。

借助 java 并发压测工具 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(user u) {
        if(ready) {
          	u.age = num + num;
        } else {
          	u.age = 1;
        }
  	}
 
    @Actor
    public void actor2(User u) {
        num = 2;
        ready = true;
    }
}

执行：

mvn clean install
java -jar target/jcstress.jar

结果：

*** INTERESTING tests   
	Some interesting behaviors observed. This is for the plain curiosity. 
 
  	2 matching test results.       
  		[OK] test.ConcurrencyTest     
  		(JVM args: [-XX:-TieredCompilation])   
  		Observed state   Occurrences              Expectation  Interpretation                
  					0         1,729   ACCEPTABLE_INTERESTING  !!!!                
  					1    42,617,915               ACCEPTABLE  ok                
  					4     5,146,627               ACCEPTABLE  ok 
 
      	[OK] test.ConcurrencyTest     
      	(JVM args: [])   
      	Observed state   Occurrences              Expectation  Interpretation                
      				0         1,652   ACCEPTABLE_INTERESTING  !!!!                
      				1    46,460,657               ACCEPTABLE  ok                
      				4     4,571,072               ACCEPTABLE  ok

解决办法：

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(User u) {
        if(ready) {
          	u.age = num + num;
        } else {
          	u.age = 1;
        }
  	}
 
    @Actor
    public void actor2(User u) {
        num = 2;
        ready = true;
    }
}

结果为：

*** INTERESTING tests   
	Some interesting behaviors observed. This is for the plain curiosity. 
  	0 matching test results.

9、volatile原理

1、说明

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

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

2、如何保证可见性

1、写屏障（sfence）保证在该屏障之前的，对共享变量的改动，都同步到主存当中。

public void actor2(User u){
  	num = 2；
    ready = true;//ready 是 volatile 赋值带写屏障，会同步到主存中
  	//写屏障之后
  	...
}

2、读屏障（lfence）保证在该屏障之后，对共享变量的读取，加载的是主存中最新的数据。

public void actor1(user u){
  	//读屏障
  	//ready 是 volatile读取值带读屏障
    if(ready){
		u.age = num + num;
    } else {
      	u.age = 1;
    }
}

在这里插入图片描述

3、如何保证有序性

1、写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后。

public void actor2(User u){
  	num = 2；
    ready = true;//ready 是 volatile 赋值带写屏障，会同步到主存中
  	//写屏障之后
  	...
}

2、读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前。

public void actor1(user u){
  	//读屏障
  	//ready 是 volatile读取值带读屏障
    if(ready){
		u.age = num + num;
    } else {
      	u.age = 1;
    }
}

在这里插入图片描述

不能解决指令交错：

  • 写屏障仅仅是保证之后的读能够读到最新的结果，但不能保证读跑到它前面的结果。
  • 有序性的保证也只能保证了本线程内相关代码不被重排序。

在这里插入图片描述

说明： t1 线程做 i+1 操作，写入1，如果对 i 加了 volatile，这里就是写屏障，只能保证写屏障之前的更改会同步到主内存中，但是它控制不了 t2 线程可能会在它之前去读取（提前读）值，最后结果是 -1。

10、double-checked-locking模式

public final class Singleton{
  	private Singleton(){}
  	private static volatile Singleton INSTANCE = null;
    public static Singleton getInstance（）{
		//实例没创建，才会进入内部的 synchronized代码块
        if(INSTANCE == null){
			synchronized(Singleton.class){
            	//此处再判断一次，可能会出现其他线程创建了实例
              	if(INSTANCE == null){
                	INSTANCE = new Singleton();
                }
            }
        }
      	return INSTANCE;
    }
}
小幸运安然
关注
专栏目录
JUC学习之共享模型之内存
m0_53157173的博客
12-25 497
JUC学习之共享模型之内存Java 内存模型可见性退不出的循环解决方法两阶段终止模式interrupt实现volatile实现同步模式之 Balking定义实现指令重排有序性指令级并行原理名词Clock Cycle TimeCPIIPC鱼罐头的故事指令重排序优化支持流水线的处理器SuperScalar 处理器CPU 缓存结构原理1. CPU 缓存结构2.CPU 缓存读3. CPU 缓存一致性诡异的结果解决方法volatile 原理内存屏障1. 如何保证可见性2.如何保证有序性volatile 不能解决指令交
共享模型之内存
xiaotai1234的博客
11-30 210
共享模型之内存 一、Java 内存模型 二、可见性 1.退不出的循环 2.解决方法 3.可见性 vs 原子性 4.原理之 CPU 缓存结构 CPU 缓存结构 CPU 缓存读 CPU 缓存一致性 内存屏障 5. 模式之 Balking 三、有序性 1.原理之指令级并行 2.诡异的结果 3.解决方法 4. 原理之 volatile 5.happens-before 6.习题 balking 模式习题 线程安全单例习题
Java并发压力测试工具（jcstress）推荐文章
gitblog_00040的博客
08-20 405
Java并发压力测试工具（jcstress）推荐文章 jcstresshttps://openjdk.org/projects/code-tools/jcstress项目地址:https://gitcode.com/gh_mirrors/jc/jcstress 项目介绍 Java Concurrency Stress（jcstress）是一个实验性的测试框架和测试套件，旨在帮助研究JVM、类库和...
《Java 并发编程》共享模型之内存
华仔仔的博客
04-14 964
Java 内存模型1. Java 内存模型1.1 原子性1.2 可见性1.3 有序性 1. Java 内存模型 Java 内存模型（Java Memory Model，JMM）是 JVM 规范中定义的一种抽象模型，用来屏蔽各种硬件和操作系统的内存访问差异，以实现让 Java 程序在各种平台下都能达到一致的内存访问效果。 JMM 体现在以下几个方面： 原子性：保证指令不受到线程上下文的影响。 可见性：保证指令不会受 CPU 缓存的影响。 有序性：保证指令不会受 CPU 指令并行优化的影响。 1.1 原子性
深入理解共享模型之内存
pleasenoerror的博客
07-09 88
深入理解共享模型之内存
附1 Java内存模型与共享变量可见性
weixin_33998125的博客
01-12 337
注：本文主要参考自《深入理解Java虚拟机（第二版）》和《深入理解Java内存模型》 1、Java内存模型（JMM） Java内存模型的主要目标：定义在虚拟机中将变量存储到内存和从内存中取出变量这样的底层细节。 注意：上边的变量指的是共享变量（实例字段、静态字段、数组对象元素），不包括线程私有变量（局部变量、方法参数），因为私有变量不会存在竞争关系。 1.1、内存模型就是一张图： 说...
Java 高并发三：Java内存模型和线程安全详解
09-01
Java内存模型（Java Memory Model，JMM）是Java...在Java高并发编程中，理解JMM是非常基础且重要的。通过掌握这些概念，开发者可以更好地理解和解决多线程环境下的数据竞争、死锁等问题，编写出高效、可靠的并发代码。
Java内存模型（JMM）：并发编程的基石
最新发布
10-28
Java内存模型（JMM）是并发编程中的核心概念，它通过定义线程与主内存之间的交互规则，确保了多线程程序的正确性和内存的一致性。理解JMM的工作原理和特性，对于编写高效、可靠的并发程序至关重要。通过使用volatile...
Java并发编程：volatile关键字解析
11-27
### Java并发编程：volatile关键字解析 #### 一、内存模型的相关概念 在深入了解`volatile`关键字之前，我们首先需要理解计算机内存模型的一些基本概念。在现代计算机系统中，CPU为了提高执行效率，会将频繁访问的...
深入Java内存模型：揭秘并发编程的基石
07-16
# 深入Java内存模型：揭秘并发编程的基石 Java作为一款被广泛采用的编程语言，自1995年由Sun Microsystems（现为Oracle的一部分）首次推出以来，一直在不断发展和完善。Java的设计理念包含了诸如跨平台性、面向对象...
三、聊聊并发 - 聊聊我对Java内存模型的认识
livolador’s blog
04-06 838
文章目录前言什么是Java内存模型JMM对并发问题的解决方案Java内存模型分析DCL内存模型对于原子性的保证内存模型之Happens-befor内存模型之as-if-serial内存模型之volatileJMM对于volatile读写的规则定义：JMM对volatile变量重排序规则定义：JMM是如何实现volatile的语义规则可见性的实现有序性的实现内存模型之finalfinal域写重排序规...
自启动管理StartupMonitor
11-03
StartupMonitor会乖乖的在后台运行，当你安装了一个软件的时候，如果它想自己偷偷自启动就必须通过StartupMonitor的这一关。 补丁说明 先 Stop StartupMonitor 然后将 StartupMonitor.exe 复制到 %SystemRoot%\ 下，替换原来的文件，即可完成汉化。
JMM测试利器-JCStress学习笔记
BASK2311的博客
05-17 581
我们前文提到，当我们对理论有一些了解，我们就渴望验证，如果无法对理论进行验证，那么我们就可能对理论将信将疑，那对于Java领域的并发理论，一向是难以测试的，更何况调试， 这不仅仅是我们的认知，OpenJDK的 者也是这么认知的:大约在2013年，也就是JDK8发布的时候，我们突然意识到没有常规的并发测试可以针对JMM的一致性进行深入探究。尝试将JMM测试贡献给JCK是徒劳的：这是概率性测试。
Java高并发测试框架JCStress
陈皮的JavaLib
04-07 1142
目录前言如何使用Jcstress二、使用步骤1.引入库2.读入数据总结 前言 如果要研究高并发，一般会借助高并发工具来进行测试。Jcstress（Java Concurrency Stress）它是OpenJDK中的一个高并发测试工具，它可以帮助我们研究在高并发场景下JVM，类库以及硬件等状况。 Jcstress学起来很简单，而且官方也提供了许多高并发场景下的测试用例，只要引入一个jar包，即可运行研究。 如何使用Jcstress 此演示用maven工程，首先需要引入jar包，核心包是必须要的，样例包非必须
并发测试工具_JUC整理笔记三之测试工具jcstress
weixin_39633134的博客
12-13 524
并发测试工具Jcstress使用教程Jcstress 全称 Java Concurrency Stress，是一种并发压力测试工具，可以帮助研究JVM、java类库和硬件中并发的正确性。Wiki地址：https://wiki.openjdk.java.net/display/CodeTools/jcstressWiki中有一个Jcstress的example，可以根据example很方便入门使用j...
Java中jcstress 高并发测试框架简单使用教程
刘小义的博客
09-14 2769
jcstress 高并发测试框架使用教程 1. 创建Maven项目 1.1 修改pom文件 <project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0" xsi:schemaLocation="http://maven.apac...
多线程如何共享变量 -- Java内存模型
大雄送你走的博客
03-20 2671
目录 主内存和工作内存 为什么要分为主内存和工作内存 Java 内存模型和运行时数据区的区别 Java 内存模型中变量的定义 内存之间交互操作 参考 主内存和工作内存 Java 内存模型（JMM：Java Memory Model）规定了所有的变量都存储在主内存中。 每条线程还有自己的工作内存，工作内存中保存了该线程使用到的变量到主内存副本拷贝。 线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存中的变量。 不同线程之间无法直接访问对方工作内存中的变量，线程间变量值的传递均需要在主内存来
Java并发编程：内存模型与通信同步详解
Java并发编程内存模型是理解并发编程精髓的关键，它不仅涉及到数据结构的共享与隔离，还包括了内存访问的规则和线程间通信的机制。掌握这些原理，能帮助开发者编写出健壮、高效的多线程应用程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值