多线程基础

Hank 2020/12/28 Java多线程

# Java线程的状态机

线程状态

# 可见性

可见性问题本质上来源于JMM内存模型，A,B线程都用到一个变量，java默认是A线程中保留一份copy，如果B线程修改了该变量，A线程并不知道。

# volatile保障可见性

使用volatile，将会强制所有线程都去内存中重新读取数据。

# 缓存行对齐

缓存行是CPU每次从内存读取数据的最小单元。
缓存行越大，局部性空间效率越高，但读取时间慢。缓存行越小，局部性空间效率越低，但读取时间快。目前多取一个平衡的值，为64字节。

问题：如果多线程并发对A数据修改，B数据恰好与A数据在同一缓存行内，那么对B数据的修改会导致整个缓存行失效，A数据也会一起失效。大量对A操作的线程需要重新加载A数据到CPU。
同一缓存行内的部分数据失效会导致整个数据失效，需要重新读取，导致效率严重下降。
解决方法就是让可能并发操作的数据不处在统一缓存和，方法之一可以给该数据前后增加无意义数据。

# 示例：缓存行对齐编程技巧

public static long COUNT = 10_000_000L;

private static class T {
    private long p1, p2, p3, p4, p5, p6, p7;
    public volatile long x = 0L;
    private long p9, p10, p11, p12, p13, p14, p15;
}

public static T[] arr = new T[2];

static {
    arr[0] = new T();
    arr[1] = new T();
}

public static void main(String[] args) throws Exception {
    CountDownLatch latch = new CountDownLatch(2);

    Thread t1 = new Thread(() -> {
        for (long i = 0; i < COUNT; i++) {
            arr[0].x = i;
        }
        latch.countDown();
    });

    Thread t2 = new Thread(() -> {
        for (long i = 0; i < COUNT; i++) {
            arr[1].x = i;
        }
        latch.countDown();
    });

    long start = System.currentTimeMillis();
    t1.start();
    t2.start();
    latch.await();
    long end = System.currentTimeMillis();
    System.out.println((end - start));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

JDK8引入了@sun.misc.Contended注解，来保证缓存行隔离效果。
要使用此注解，需要接触限制参数：-XX:-RestrictContended。
该功能仅在JDK1.8生效，故不深究。

# 有序性

# as-if-serial

从我们的程序运行到CPU真正执行指令的过程中，无论哪个阶段发生指令重排序，能且仅能保证在单行程下，程序的执行结果一致。

仅能保证as-if-serial的后果是，在多线程下可能产生非预期的结果。

# hanppens-before原则（JVM规定重排序必须遵守的规则）

程序次序规则：同一个线程内，按照代码出现的顺序，前面的代码先行于后面的代码，准确的说是控制流顺序，因为要考虑到分支和循环结构。
管程锁定规则：一个unlock操作先行发生于后面（时间上）对同一个锁的lock操作。
volatile变量规则：对一个volatile变量的写操作先行发生于后面（时间上）对这个变量的读操作。
线程启动规则：Thread的start( )方法先行发生于这个线程的每一个操作。
线程终止规则：线程的所有操作都先行于此线程的终止检测。可以通过Thread.join( )方法结束、Thread.isAlive( )的返回值等手段检测线程的终止。
线程中断规则：对线程interrupt( )方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过Thread.interrupt( )方法检测线程是否中断。
对象终结规则：一个对象的初始化完成先行于发生它的finalize()方法的开始。
传递性：如果操作A先行于操作B，操作B先行于操作C，那么操作A先行于操作C。

# 使用内存屏障防止乱序

内存屏障是特殊指令：看到这种指令，前面的必须执行完，后面的才能执行。

所有实现JVM规范的虚拟机，必须实现四个屏障：

LoadLoadBarrier
LoadStore
SL
SS

# 使用volatile防止乱序

volatile修饰的内存，不可以重排序，对volatile修饰变量的读写访问，都不可以换顺序。

DCL单例要不要加volatile？
需要，new对象的操作不是原子的。

# 原子性

某个操作的过程中间不会被打断。
为了保障操作的原子性，需要借助锁。

# 什么样的语句（指令）具备原子性？

1.CPU级别的原子操作，需要查询汇编手册。

2.Java中的8大原子操作：

lock：主内存，标识变量为线程独占
unlock：主内存，解锁线程独占变量
read：主内存，读取内存到线程缓存（工作内存）
load：工作内存，read后的值放入线程本地变量副本
use：工作内存，传值给执行引擎
assign：工作内存，执行引擎结果赋值给线程本地变量
store：工作内存，存值到主内存给write备用
write：主内存，写变量值

Hank的博客

Choose mode