第五章、共享模型之内存

最新推荐文章于 2024-04-19 04:12:09 发布

浮华1994

最新推荐文章于 2024-04-19 04:12:09 发布

阅读量124

点赞数 1

分类专栏： java并发编程文章标签：并发多线程

本文链接：https://blog.csdn.net/qq_22494169/article/details/115670428

版权

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

7 篇文章 1 订阅

订阅专栏

深入学习共享变量在多线程间的【可见性】问题与多条指令执行时的【有序性】问题

Java 内存模型

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

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

可见性

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

/**
 * @author sunfeng    可见性问题
 * @date 2021/04/13 15:44
 **/

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

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

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

        TimeUtils.sleep(1);
        log.debug("停止T");
        run = false;
    }
}

为什么呢？分析一下：

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

解决方法

1、volatile（易变关键字）

将 static boolean run = true;   改为  static volatile boolean run = true;

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

/**
 * @author sunfeng    可见性问题
 * @date 2021/04/13 15:44
 **/

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

    // 演示 synchronized

    final static Object lock = new Object();

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

        TimeUtils.sleep(1);
        log.debug("停止T");
        synchronized (lock) {
            run = false;
        }
    }
}

可见性 vs 原子性

前面例子体现的实际就是可见性，它保证的是在多个线程之间，一个线程对 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 - - ，volatile只能保证看到最新值，不能解决指令交错

// 假设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 变量的修改了，想一想为什么？

模式之两阶段终止（优雅的停止线程）

在这里插入图片描述

利用 isInterrupted

interrupt 可以打断正在执行的线程，无论这个线程是在 sleep，wait，还是正常运行

/**
 * @author sunfeng
 * @date 2021/04/13 16:12
 **/

@Slf4j(topic = "c.TPTInterrupt")
public class TPTInterrupt {
    private Thread thread;

    public static void main(String[] args) throws InterruptedException {
        TPTInterrupt t = new TPTInterrupt();
        t.start();
        Thread.sleep(3500);
        log.debug("stop");
        t.stop();
    }


    public void start() {
        thread = new Thread(() -> {
            while (true) {
                Thread current = Thread.currentThread();
                if (current.isInterrupted()) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                    log.debug("将结果保存");
                } catch (InterruptedException e) {
                		//  线程的中端标志会被重置，需要重新设置中断状态
                    current.interrupt();

                }
            }

        }, "监控线程");

        thread.start();
    }

    public void stop() {
        thread.interrupt();
    }
}

结果

16:17:34.281 c.TPTInterrupt [监控线程] - 将结果保存
16:17:35.284 c.TPTInterrupt [监控线程] - 将结果保存
16:17:36.285 c.TPTInterrupt [监控线程] - 将结果保存
16:17:36.779 c.TPTInterrupt [main] - stop
16:17:36.779 c.TPTInterrupt [监控线程] - 料理后事

利用停止标记

/**
 * 停止标记用 volatile 是为了保证该变量在多个线程之间的可见性
 *
 * @author sunfeng
 * @date 2021/04/13 16:18
 **/

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

    private Thread thread;

    private volatile boolean stop = false;


    public static void main(String[] args) throws InterruptedException {
        TPTVolatile aVolatile = new TPTVolatile();
        aVolatile.start();
        Thread.sleep(3500);
        log.debug("stop");
        aVolatile.stop();

    }


    public void start() {
        thread = new Thread(() -> {

            while (true) {
                if (stop) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    TimeUnit.SECONDS.sleep(1);
                    log.debug("将结果保存");
                } catch (InterruptedException e) {
                    log.error("线程被打断");
                }
            }

        }, "监控线程");

        thread.start();
    }

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

结果

16:24:54.314 c.TPTVolatile [监控线程] - 将结果保存
16:24:55.318 c.TPTVolatile [监控线程] - 将结果保存
16:24:56.319 c.TPTVolatile [监控线程] - 将结果保存
16:24:56.813 c.TPTVolatile [main] - stop
16:24:56.813 c.TPTVolatile [监控线程] - 线程被打断
16:24:56.813 c.TPTVolatile [监控线程] - 料理后事

同步模式之 Balking（犹豫模式）

定义

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

实现

例如：

/**
 * 同步模式之Balking模式
 *
 * @author sunfeng
 * @date 2021/04/13 16:27
 **/
@Slf4j(topic = "c.MonitorService")
public class MonitorService {

    /**
     * 用来表示是否已经有线程已经在执行启动了
     */
    private volatile boolean starting;

    public static void main(String[] args) {
        MonitorService monitorService = new MonitorService();

        Thread t1 = new Thread(() -> {
            monitorService.start();
        }, "t1");
        t1.start();
        Thread t2 = new Thread(() -> {
            monitorService.start();
        }, "t2");
        t2.start();
        Thread t3 = new Thread(() -> {
            monitorService.start();
        }, "t3");
        t3.start();
    }

    public void start() {
        log.info("尝试启动监控线程...");
        // 保证只有一个线程可以执行   
        synchronized (this) {
            log.debug("线程是否已经启动？：{}",starting);
            if (starting) {
                return;
            }
            starting = true;
        }
        // 真正启动监控线程...  保证这里只有一个线程可以真正执行
        Thread thread = new Thread(() -> {
            while (true){
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("执行监控操作");
            }

        },"监控线程");
        thread.start();

    }
}

结果

16:32:29.137 c.MonitorService [t1] - 尝试启动监控线程...
16:32:29.137 c.MonitorService [t3] - 尝试启动监控线程...
16:32:29.137 c.MonitorService [t2] - 尝试启动监控线程...
16:32:29.140 c.MonitorService [t1] - 线程是否已经启动？：false
16:32:29.142 c.MonitorService [t2] - 线程是否已经启动？：true
16:32:29.142 c.MonitorService [t3] - 线程是否已经启动？：true
16:32:30.144 c.MonitorService [监控线程] - 执行监控操作
16:32:31.144 c.MonitorService [监控线程] - 执行监控操作
16:32:32.145 c.MonitorService [监控线程] - 执行监控操作
16:32:33.146 c.MonitorService [监控线程] - 执行监控操作
16:32:34.146 c.MonitorService [监控线程] - 执行监控操作

应用

两阶段终止模式吧和犹豫模式结合

/**
 * 同步模式之Balking模式
 *
 * @author sunfeng
 * @date 2021/04/13 16:27
 **/
@Slf4j(topic = "c.MonitorService")
public class MonitorService {

    /**
     * 用来表示是否已经有线程已经在执行启动了
     */
    private volatile boolean starting;

    private volatile boolean stop;

    private  Thread monitorThread;

    public static void main(String[] args) throws InterruptedException {
        MonitorService monitorService = new MonitorService();

        Thread t1 = new Thread(() -> {
            monitorService.start();
        }, "t1");
        t1.start();
        Thread t2 = new Thread(() -> {
            monitorService.start();
        }, "t2");
        t2.start();
        Thread t3 = new Thread(() -> {
            monitorService.start();
        }, "t3");
        t3.start();


        TimeUnit.SECONDS.sleep(5);
        monitorService.stop();
    }

    public void start() {
        log.info("尝试启动监控线程...");
        synchronized (this) {
            log.debug("线程是否已经启动？：{}", starting);
            if (starting) {
                return;
            }
            starting = true;
        }
        // 真正启动监控线程...
        monitorThread = new Thread(() -> {
            while (!stop) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                    log.debug("执行监控操作");
                } catch (InterruptedException e) {
                   log.debug("监控线程开始停止");
                }
            }
            log.debug("监控线程已经停止");
            stop = false;
        }, "监控线程");

        stop = false;

        log.debug("监控线程已经启动");

        monitorThread.start();

    }

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

实现单例模式

/**
 * @author sunfeng
 * @date 2021/04/13 16:53
 **/
public final class Singleton {
    private 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 = ...;

也可以是

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

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

指令级并行

名词

Clock Cycle Time
主频的概念大家接触的比较多，而 CPU 的 Clock Cycle Time（时钟周期时间），等于主频的倒数，意思是 CPU 能
够识别的最小时间单位，比如说 4G 主频的 CPU 的 Clock Cycle Time 就是 0.25 ns，作为对比，我们墙上挂钟的
Cycle Time 是 1s
例如，运行一条加法指令一般需要一个时钟周期时间
CPI
有的指令需要更多的时钟周期时间，所以引出了 CPI （Cycles Per Instruction）指令平均时钟周期数
IPC
IPC（Instruction Per Clock Cycle）即 CPI 的倒数，表示每个时钟周期能够运行的指令数
CPU 执行时间
程序的 CPU 执行时间，即我们前面提到的 user + system 时间，可以用下面的公式来表示

鱼罐头的故事

加工一条鱼需要 50 分钟，只能一条鱼、一条鱼顺序加工…
在这里插入图片描述
可以将每个鱼罐头的加工流程细分为 5 个步骤：

去鳞清洗 10分钟
蒸煮沥水 10分钟
加注汤料 10分钟
杀菌出锅 10分钟
真空封罐 10分钟

即使只有一个工人，最理想的情况是：他能够在 10 分钟内同时做好这 5 件事，因为对第一条鱼的真空装罐，不会
影响对第二条鱼的杀菌出锅…

指令重排序优化

事实上，现代处理器会设计为一个时钟周期完成一条执行时间最长的 CPU 指令。为什么这么做呢？可以想到指令
还可以再划分成一个个更小的阶段，例如，每条指令都可以分为：取指令 - 指令译码 - 执行指令 - 内存访问 - 数据
写回这 5 个阶段
在这里插入图片描述
在不改变程序结果的前提下，这些指令的各个阶段可以通过重排序和组合来实现指令级并行，这一技术在 80年代中叶到 90年代中叶占据了计算架构的重要地位。
提示：
分阶段，分工是提升效率的关键！
指令重排的前提是，重排指令不能影响结果，例如

// 可以重排的例子
int a = 10; // 指令1
int b = 20; // 指令2
System.out.println( a + b );
// 不能重排的例子
int a = 10; // 指令1
int b = a - 5; // 指令2

支持流水线的处理器

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

SuperScalar 处理器

大多数处理器包含多个执行单元，并不是所有计算功能都集中在一起，可以再细分为整数运算单元、浮点数运算单
元等，这样可以把多条指令也可以做到并行获取、译码等，CPU 可以在一个时钟周期内，执行多于一条指令，IPC>1 在这里插入图片描述

诡异的结果

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.sunfeng -DartifactId=ordering -Dversion=1.0

生成代码
在这里插入图片描述
修改测试代码

@JCStressTest
@Outcome(id = {"1","4"}, expect = Expect.ACCEPTABLE, desc = "od")
@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

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

*** INTERESTING tests
  Some interesting behaviors observed. This is for the plain curiosity.

  2 matching test results.
      [OK] cn.sunfeng.ConcurrencyTest
    (JVM args: [-XX:-TieredCompilation])
  Observed state   Occurrences              Expectation  Interpretation
               0         4,844   ACCEPTABLE_INTERESTING  !!!!!!
               1    56,732,162               ACCEPTABLE  od
               4    56,917,595               ACCEPTABLE  od

      [OK] cn.sunfeng.ConcurrencyTest
    (JVM args: [])
  Observed state   Occurrences              Expectation  Interpretation
               0         2,072   ACCEPTABLE_INTERESTING  !!!!!!
               1    39,329,881               ACCEPTABLE  od
               4    47,814,058               ACCEPTABLE  od

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

解决方法

volatile 修饰的变量，可以禁用指令重排
在这里插入图片描述
查看结果

*** INTERESTING tests
  Some interesting behaviors observed. This is for the plain curiosity.

  0 matching test results.

说明不会发生感兴趣的 0 的结果

volatile 原理

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

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

如何保证可见性

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

public void actor2(I_Result r) {
	num = 2;
	ready = true; // ready 是 volatile 赋值带写屏障
	// 写屏障
}

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

   public void actor1(I_Result r) {
        if(ready) {
            r.r1 = num + num;
        } else {
            r.r1 = 1;
        }
    }

在这里插入图片描述

如何保证有序性

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

public void actor2(I_Result r) {
	num = 2;
	ready = true; // ready 是 volatile 赋值带写屏障
	// 写屏障
}

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

public void actor1(I_Result r) {
// 读屏障
//read 是volatile 读取值带读屏障
    if(ready) {
        r.r1 = num + num;
    } else {
        r.r1 = 1;
    }
}

在这里插入图片描述
还是那句话，不能解决指令交错：

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

浮华1994

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录