多线程并发原理

小镇早晨
618 阅读11分钟

CPU层高速缓存

我们知道代码编译后会生成指令在CPU中执行，而执行指令时会对主内存的数据进行读写操作。因为CPU的执行指令速度远远大于数据读写，于是CPU设计了高速缓存，将主内存数据拷入到高速缓存中进行操作，数据变更后又会在特定的时刻写入到主内存。如下图：

这样的设计提高了执行指令效率，但是同样带来了多个CPU(线程)协同时数据的同步问题。

比如：cpu1拿到主内存的数据进行一番操作后，还未将数据写道主内存，cpu2就去拿数据，最后cpu1和cpu2都将数据写入主内存中，于是有一个cpu的计算结果相当于无效了。

针对于上面的问题，CPU层面提供了总线锁和缓存锁两种方案。

  • 总线锁是比较暴力且低效的，当一个cpu获取一个主内存的数据时，就会再总线（cpu和主内存通信信道）上发出一个LOCK#信号来防止其他cpu读取主内存数据。

  • 缓存锁则是基于缓存一致性协议，当一个cpu把数据写回到主内存时，其他处理器使用了该数据的缓存会置为无效。

CPU高速缓存那些事儿

缓存一致性协议（MESI）

MESI表示缓存行的四种状态，分别是：

  1. M(Modify) 表示共享数据只缓存在当前CPU中，且是被修改状态。
  2. E(Exclusive) 表示共享数据只缓存在当前CPU中，且未被修改状态。
  3. S(Shared) 表示共享数据缓存在多个CPU中，且各个缓存中的数据和主内存数据一致。
  4. I(Invalid) 表示缓存已经失效。

在 MESI 协议中，每个cpu不仅知道自己的读写操作，而且也监听(snoop)其它CPU的读写操作（嗅探机制），并且遵循以下原则：

  • CPU读请求：缓存处于 M、E、S 状态都可以被读取，I 状态CPU 只能从主存中读取数据
  • CPU写请求：缓存处于 M、E 状态才可以被写。对于S状态的写，需要将其他CPU中缓存行置为无效才行。

内存屏障

MESI虽然解决了缓存一致的问题，但是依然比较低效，比如要收到其他所有cpu已将数据置为无效的消息后，才可以继续执行当前cpu的操作。为了解决这段时间的阻塞，引入了store bufferes。

CPU 在将数据写入到主内存前，直接把数据写入到 store bufferes中，同时发送invalidate消息，然后就继续去处理其他指令（未阻塞），等收到其他所有CPU已将自己缓存置为无效的消息时，再将store bufferes中的数据存储至缓存行中，最后再从缓存行同步到主内存。但CPU的无序执行又会引起可见性问题，因此引入了内存屏障的概念。

内存屏障有Load屏障和Store屏障，基于他们两两组合，有以下四种：

  • LoadLoad屏障：
    对于这样的语句Load1; LoadLoad; Load2;
    保证Load1读取操作早于Load2及后续读取操作。

  • StoreStore屏障：
    对于这样的语句Store1; StoreStore; Store2;
    保证Store1的写入操作早于Store2及后续写入操作。

  • LoadStore屏障：
    对于这样的语句Load1; LoadStore; Store2;
    保证Load1读取操作早于Store2及后续写入操作。

  • StoreLoad屏障：
    对于这样的语句Store1; StoreLoad; Load2;
    保证Store1的写入操作早于Load2及后续读取操作。

注：上面的写入和读取是指从主存中读取和写入主存中

volatile的内部原理

都知道volatile能保证可见性和禁止排序，其实内部就使用了MESI和内存屏障。

volatile编译后会在指令前增加一个lock的指令，早期是使用总线锁，因为成本太大，后来变成是缓存锁。

  • intel的手册对lock前缀的说明：确保对内存的读-改-写操作原子执行。在Pentium及Pentium之前的处理器中，带有lock前缀的指令在执行期间会锁住总线，使得其他处理器暂时无法通过总线访问内存。很显然，这会带来昂贵的开销。从Pentium 4，Intel Xeon及P6处理器开始，intel在原有总线锁的基础上做了一个很有意义的优化：如果要访问的内存区域（area of memory）在lock前缀指令执行期间已经在处理器内部的缓存中被锁定（即包含该内存区域的缓存行当前处于独占或以修改状态），并且该内存区域被完全包含在单个缓存行（cache line）中，那么处理器将直接执行该指令。由于在指令执行期间该缓存行会一直被锁定，其它处理器无法读/写该指令要访问的内存区域，因此能保证指令执行的原子性。这个操作过程叫做缓存锁定（cache locking），缓存锁定将大大降低lock前缀指令的执行开销，但是当多处理器之间的竞争程度很高或者指令访问的内存地址未对齐时，仍然会锁住总线。
  • 禁止该指令与之前和之后的读和写指令重排序。
  • 把写缓冲区中的所有数据刷新到内存中。

volatile的内存语义

  • volatile的读操作
    后面插入LoadLoad屏障和LoadStore屏障。
  • volatile写操作
    前面插入一个StoreStore屏障，后面插入一个SotreLoad屏障。

java内存模型（JMM）

JMM与硬件层的关系

Java内存模型的八种操作

线程间通信其实都是要经过主内存的，关于主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步到主内存之间的实现细节，Java内存模型定义了以下八种操作来完成：

  1. lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态。
  2. unlock（解锁）：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
  3. read（读取）：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用
  4. load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。
  5. use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
  6. assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
  7. store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。
  8. write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。

Java内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：

  1. 如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作， 如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。但Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。
  2. 不允许read和load、store和write操作之一单独出现
  3. 不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。
  4. 不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。
  5. 一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。
  6. 一个变量在同一时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁。lock和unlock必须成对出现
  7. 如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值
  8. 如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。
  9. 对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）。

原子性、可见行、有序性这三个特性。

  • 原子性 操作不可中断，操作未结束，不可切换到别的线程。

以下为例子：

i = 2;
j = i;
i++; 和 i = i + 1；

i = 2 只有一步，“给i赋值操作”，是原子性操作。
j = i 有两个步骤，“读取i的值”，“给j赋值”，因此不具备原子性。
i++ 和 i = i + 1是等价的，包含三个步骤，“读取i的值”，“进行加1操作”，“给i赋值”，因此不具备原子性。

  • 可见性 修改一个具备可见性的变量，会立刻同步到主存，当其它线程需要读取该变量时，会去主存中读取新值。
    对于普通的变现，在多线程中会出现问题： i的初始值为0，两个线程对i进行++操作，根据上面分析，i++是有三个步骤，线程1从主存中获取i，+1后同步到主内存，此时切到线程2从主存中获取获取i为0，然后+1，此时
Thread thread1 = new Thread(new Runnable() {
        @Override
        public void run() {
            i++;
        }
    });

    Thread thread2 = new Thread(new Runnable() {
        @Override
        public void run() {
            i++;
        }
    });
  • 有序性

虚拟机允许编译器和处理器对指令进行重排序，但是会遵守数据依赖性，不会改变存在数据依赖关系的两个操作的执行顺序。这也就是as-if-serial语义，让开发者觉得“就好像是串行”的。另外一个 happens-before规则：

具体的规则：

  1. 程序顺序规则：一个线程中的每个操作，happens-before于该线程中的任意后续操作。
  2. 监视器锁规则：对一个锁的解锁，happens-before于随后对这个锁的加锁。
  3. volatile变量规则：对一个volatile域的写，happens-before于任意后续对这个volatile域的读。
  4. 传递性：如果A happens-before B，且B happens-before C，那么A happens-before C。
  5. start()规则：如果线程A执行操作ThreadB.start()（启动线程B），那么A线程的ThreadB.start()操作happens-before于线程B中的任意操作。
  6. Join()规则：如果线程A执行操作ThreadB.join()并成功返回，那么线程B中的任意操作happens-before于线程A从ThreadB.join()操作成功返回。
  7. 程序中断规则：对线程interrupted()方法的调用happens-before于被中断线程的代码检测到中断时间的发生。
  8. 对象finalize规则：一个对象的初始化完成（构造函数执行结束）happens-before于发生它的finalize()方法的开始。

下面的代码说明了重排序后，会出现空指针的问题，线程1重排序，先设置isInit = true，未初始化对象，切到线程2后，会直接调用mPrinter.print()，从而出现空指针。

Thread thread1 = new Thread(new Runnable() {
        @Override
        public void run() {
            mPrinter = new Printer();
            isInit = true;
        }
    });

    Thread thread2 = new Thread(new Runnable() {
        @Override
        public void run() {
            if (isInit) {
                mPrinter.print();
            }
        }
    });

Synchronized

Synchronized的底层实现原理（原理解析，面试必备）_synchronized底层实现原理-CSDN博客

avatar
文章
阅读
粉丝

友情链接：