多线程理论知识

为什么需要多线程

  1. 摩尔定律失效(硬件方面)
  2. 高并发系统，异步+回调的生产需求(软件方面)

众所周知，CPU、内存、I/O 设备的速度是有极大差异的，为了合理利用 CPU 的高性能，平衡这三者的速度差异，计算机体系结构、操作系统、编译程序都做出了贡献，主要体现为:

  • CPU 增加了缓存，以均衡与内存的速度差异；// 导致 可见性问题
  • 操作系统增加了进程、线程，以分时复用 CPU，进而均衡 CPU 与 I/O 设备的速度差异；// 导致 原子性问题
  • 编译程序优化指令执行次序，使得缓存能够得到更加合理地利用。// 导致 有序性问题

生产者消费者问题

生产者消费者问题 是典型的 线程不安全示例

  • 生产者消费者模式是一个十分经典的多线程协作的模式，弄懂生产者消费者问题能够让我们对多线程编程的理解更加深刻。所谓生产消费者问题，实际上主要是包含了两类线程：
    • 一类是生产者线程用于生产数据
    • 一类是消费者线程用于消费数据
  • 为了耦合生产者和消费者的关系，通常会采用共享的数据区域，就像一个仓库。生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为，消费者只需要从共享数据区中获取数据，并不需要关心生产者的行为。
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
package tech.chen.juccode.a02;
/**
 * @Date 2022/8/19 19:53
 * @Author c-z-k
 */
public class producersAndConsumers {
    public static void main(String[] args) {
        AirCondition airCondition=new AirCondition();
        new Thread(()->{ for (int i = 1; i <11 ; i++) airCondition.increment();},"线程A").start();
        new Thread(()->{ for (int i = 1; i <11 ; i++) airCondition.decrement();},"线程B").start();
        new Thread(()->{ for (int i = 1; i <11 ; i++) airCondition.increment();},"线程C").start();
        new Thread(()->{ for (int i = 1; i <11 ; i++) airCondition.decrement();},"线程D").start();
    }
    static class AirCondition{
        private int number=0;

        public void increment(){
            number++;
            System.out.println(Thread.currentThread().getName()+":"+number);
        } 
        public void decrement(){
            number--;
            System.out.println(Thread.currentThread().getName()+":"+number);
        }
    }
}

并发出现问题的根源: 并发三要素

可见性: CPU缓存引起

可见性：一个线程对共享变量的修改，另外一个线程能够立刻看到。

举个例子：

1
2
3
4
5
6
7
8
9
public class Main{
    private int a = 0;
    public void ad(){
        a = 1;
    }
    public void re(){
        int j = a;
    }
}

现有两个线程 A ,B。A执行 ad() ,B执行 re(),当线程 A 执行 a =1 时，会先把 a 的初始值加载到 CPU-A 的高速缓存中，然后赋值为1，那么在CPU-A 的高速缓存当中i的值变为10了，却没有立即写入到主存当中。此时线程 B 执行 j = a ，它会先去主存读取 a 的值并加载到 CPU-B 的缓存当中，注意此时内存当中 a 的值还是0，那么就会使得 j 的值为0，而不是10。

原子性: 分时复用引起

原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

举个例子：

1
2
3
4
5
6
public class Main{
    private int a = 0;
    public void ad(){
        a += 1;
    }
}

这里需要注意的是：a += 1 需要三条 CPU 指令

  1. 将变量 a 从内存读取到 CPU寄存器；
  2. 在CPU寄存器中执行 a+ 1 操作；
  3. 将最后的结果i写入内存（缓存机制导致可能写入的是 CPU 缓存而不是内存）。

由于CPU分时复用（线程切换）的存在，线程A执行了第一条指令后，就切换到线程B执行，假如线程B执行了这三条指令后，再切换会线程A执行后续两条指令，将造成最后写到内存中的 a 值是2而不是3。

有序性: 重排序引起

有序性：即程序执行的顺序按照代码的先后顺序执行。

举个例子：

1
2
3
4
5
6
7
8
public class Main{
    private int a = 0;
    private boolean b = false;
    public void show(){
        a = 1;			//语句1  
        b = true;   	//语句2  
    }
}

上面代码定义了一个 int 型变量，定义了一个boolean类型变量，然后分别对两个变量进行赋值操作。从代码顺序上看，语句1是在语句2前面的，那么 JVM 在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗? 不一定，为什么呢? 这里可能会发生指令重排序（Instruction Reorder）。

在执行程序时为了提高性能，编译器和处理器常常会对指令做重排序。重排序分三种类型：

  • 编译器优化的重排序。编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。
  • 指令级并行的重排序。现代处理器采用了指令级并行技术（Instruction-Level Parallelism， ILP）来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
  • 内存系统的重排序。由于处理器使用缓存和读 / 写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。

从 java 源代码到最终实际执行的指令序列，会分别经历下面三种重排序：

img

上述的 1 属于编译器重排序，2 和 3 属于处理器重排序。这些重排序都可能会导致多线程程序出现内存可见性问题。对于编译器，JMM 的编译器重排序规则会禁止特定类型的编译器重排序（不是所有的编译器重排序都要禁止）。对于处理器重排序，JMM 的处理器重排序规则会要求 java 编译器在生成指令序列时，插入特定类型的内存屏障（memory barriers，intel 称之为 memory fence）指令，通过内存屏障指令来禁止特定类型的处理器重排序（不是所有的处理器重排序都要禁止）。

JMM(Java内存模型)

JAVA 是通过 JMM 来解决 并发问题的

JMM本质上可以理解为，Java 内存模型规范了 JVM 如何提供按需禁用缓存和编译优化的方法。具体来说，这些方法包括：

  • volatile、synchronized 和 final 三个关键字
  • Happens-Before 规则

原子性：

Java 内存模型只保证了基本读取和赋值是原子性操作，如果要实现更大范围操作的原子性，可以通过 synchronized 和 Lock 来实现。由于 synchronized 和 Lock 能够保证任一时刻只有一个线程执行该代码块，那么自然就不存在原子性问题了，从而保证了原子性。

可见性：

Java提供了 volatile 关键字来保证可见性。

  • 当一个共享变量被 volatile 修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。
  • 而普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。

另外，通过 synchronized 和 Lock 也能够保证可见性，synchronized 和 Lock 能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。

有序性：

在Java里面，可以通过 volatile 关键字来保证一定的“有序性”（具体原理在后边讲述）。另外可以通过 synchronized 和 Lock 来保证有序性，很显然，synchronized 和 Lock 保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。当然 JMM 是通过Happens-Before 规则来保证有序性的。

Happens-Before 规则

先行发生原则 ：一个操作无需控制就能先于另一个操作完成。

  1. 单一线程原则 ：在一个线程内，在程序前面的操作先行发生于后面的操作。
  2. 管程锁定规则 ：一个 unlock 操作先行发生于后面对同一个锁的 lock 操作。
  3. volatile 变量规则 ：对一个 volatile 变量的写操作先行发生于后面对这个变量的读操作。
  4. 线程启动规则 ：Thread 对象的 start() 方法调用先行发生于此线程的每一个动作。
  5. 线程加入规则 ：Thread 对象的结束先行发生于 join() 方法返回。
  6. 线程中断规则 ：对线程 interrupt() 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过 interrupted() 方法检测到是否有中断发生。
  7. 对象终结规则 ：一个对象的初始化完成(构造函数执行结束)先行发生于它的 finalize() 方法的开始。
  8. 传递性：如果操作 A 先行发生于操作 B，操作 B 先行发生于操作 C，那么操作 A 先行发生于操作 C。

线程安全的实现方法

阻塞同步

synchronized 和 ReentrantLock。后边章节详解

非阻塞同步

CAS

随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略: 先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施(不断地重试，直到成功为止)。这种乐观的并发策略的许多实现都不需要将线程阻塞，因此这种同步操作称为非阻塞同步。

乐观锁需要操作和冲突检测这两个步骤具备原子性，这里就不能再使用互斥同步来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是: 比较并交换(Compare-and-Swap，CAS)。CAS 指令需要有 3 个操作数，分别是内存地址 V、旧的预期值 A 和新值 B。当执行操作时，只有当 V 的值等于 A，才将 V 的值更新为 B。

AtomicInteger

J.U.C 包里面的整数原子类 AtomicInteger，其中的 compareAndSet() 和 getAndIncrement() 等方法都使用了 Unsafe 类的 CAS 操作。

以下代码使用了 AtomicInteger 执行了自增的操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private AtomicInteger cnt = new AtomicInteger();

public void add() {
    cnt.incrementAndGet();
}
//以下代码是 incrementAndGet() 的源码，它调用了 unsafe 的 getAndAddInt() 。
public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
//以下代码是 getAndAddInt() 源码
public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值等于 var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。

可以看到 getAndAddInt() 在一个循环中进行，发生冲突的做法是不断的进行重试。

ABA

如果一个变量初次读取的时候是 A 值，它的值被改成了 B，后来又被改回为 A，那 CAS 操作就会误认为它从来没有被改变过。

J.U.C 包提供了一个带有标记的原子引用类 AtomicStampedReference 来解决这个问题，它可以通过控制变量值的版本来保证 CAS 的正确性。大部分情况下 ABA 问题不会影响程序并发的正确性，如果需要解决 ABA 问题，改用传统的互斥同步可能会比原子类更高效。

无同步方案

要保证线程安全，并不是一定就要进行同步。如果一个方法本来就不涉及共享数据，那它自然就无须任何同步措施去保证正确性。

(一)栈封闭

多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在虚拟机栈中，属于线程私有的

1
2
3
4
5
6
7
8
9
public class Main{
	public void add100() {
        int a= 0;
        for (int i = 0; i < 100; i++) {
            a++;
        }
        System.out.println(a);
    }
}

(二)线程本地存储(Thread Local Storage)

如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。如果能保证，我们就可以把共享数据的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。

java中 可以使用 java.lang.ThreadLocal 类来实现线程本地存储功能。

后边章节详解