java并发编程的艺术

java并发编程的艺术

第一章--并发的挑战

1。上下文切换

上下文切换是由于多任务操作系统需要管理多个线程或进程的并发

第二章---java并发机制的底层实现原理

java代码编译成字节码，然后被类加载器加载到jvm中，jvm执行，最终转换为汇编指令在cpu上执行，java的并发机制依赖于jvm和cpu的指令。

1.volatile的应用

volatile加在共享变量上，保证所有线程看到这个变量的值是一致的，即valoatile变量相当于加了一个读写锁，是通过原子操作实现的。

实现原理：汇编代码给volatile变量加了lock前缀指令。

lock指令：将当前cpu缓存的volatile变量写回系统内存，使其他cpu缓存中的volatile变量数据无效。

MESI 协议是一种常见的缓存一致性协议，用于处理多处理器系统中的缓存一致性问题。

1.Modified（M）

：这个状态表示缓存行已被修改，并且与主存中的数据不一致。这意味着这个缓存行中的数据是处理器专有的，并且尚未写回主存。其他处理器无权访问此缓存行。

2.Exclusive（E）私有的

：这个状态表示缓存行是干净的，与主存中的数据一致。这个缓存行只存在于一个处理器的缓存中，其他处理器没有副本。当一个处理器读取数据时，数据会从主存加载到这个处理器的缓存中，并切换到 Exclusive 状态。

3.Shared（S）

：这个状态表示缓存行是干净的，与主存中的数据一致。多个处理器可以拥有这个缓存行的副本，因此在多处理器系统中，它可以存在于多个处理器的缓存中。如果一个处理器写入了这个缓存行，它必须先将其转换为 Modified 状态，然后进行修改。

4.Invalid（I）

：这个状态表示缓存行是无效的，无法使用。这可能是因为其他处理器修改了与之相关的数据，或者处理器主动将其标记为无效。在 Invalid 状态下，缓存行不能用于读或写操作。

MESI 协议的一般实现方式：

1.状态标记

：每个缓存行都有一个状态标记，用于表示它的状态，可以是 Modified（M）、Exclusive（E）、Shared（S）、或 Invalid（I）之一。处理器在缓存中维护这些标记，以跟踪每个缓存行的状态。

2.缓存操作

：当处理器进行缓存读取或写入操作时，MESI 协议规定了缓存状态的转换条件。例如，如果一个处理器要读取一个缓存行，但当前状态为 Invalid（I），则它必须从主存中加载数据，将状态转换为 Exclusive（E）或 Shared（S），并执行读取操作。

3.写回和写分配

：当处理器对一个缓存行执行写入操作时，MESI 协议规定了数据如何写回主存以保持一致性。如果一个缓存行处于 Modified（M）状态，写回主存是必需的，然后状态转换为 Exclusive（E）。如果处于 Exclusive（E）状态，写入操作可以直接写入缓存，不需要写回主存。

4.缓存间通信

：当一个处理器修改一个缓存行并使其状态从 Exclusive（E）转换为 Modified（M）时，它必须通知其他可能拥有该缓存行的处理器。这通常涉及到发送消息或信号给其他处理器，以通知它们相应缓存行的状态变化。

5.原子操作

：在某些情况下， MESI 协议需要保证多个缓存操作是原子的，以确保数据一致性。这可能涉及到使用原子操作来实现状态的转换和数据的读写，以防止竞态条件。

MESI 协议的实现要求硬件支持，并且通常由处理器内部的缓存控制逻辑来管理。硬件支持 MESI 协议可以确保缓存状态的正确管理和转换，从而确保数据的一致性。不同的处理器架构和硬件实现可能会略有不同，但遵循了 MESI 协议的一般原则。

1.缓存锁定（Cache Locking）：缓存行锁后，其他缓存中的share状态数据转换为invalid，需要重新加载。

：

• 缓存锁定是一种方法，通过它可以锁定缓存中的某些数据，防止其被其他处理器修改。
• 当一个处理器锁定缓存中的数据时，其他处理器将不能修改或访问这些数据，从而确保数据一致性。
• 缓存锁定通常以粒度更细的方式进行，例如锁定某个特定的缓存行，而不是整个缓存。
• 这种方法通常会引入更低的争用，因为只有某些数据被锁定，而其他数据可以继续并发访问。
  2.总线锁定（Bus Locking）：锁总线后，其他cpu无法访问内存，从而保证一致性，但是很影响性能。
  同时处理器也实现了嗅探技术来保证缓存一致性。
  嗅探技术：
  当一个处理器中的缓存进行修改后，会在总线上通知其他处理器，将其他处理器的share状态改变为invalid。
  硬件的缓存一致性是通过，MESI状态转换和嗅探技术实现的。

2.synchronized的实现

synchronized保证一个方法或者代码块同时只有一个线程执行（不会发生中断和抢占）。

（1）Java中每个对象都可以作为锁（对象头）

具体实现：

《1》普通同步方法：锁是当前实例对象。

《2》静态同步方法：锁是当前类的class文件。

《3》对于配置了synchonized对象的，锁是配置对象。

当进程访问代码块时，必须先得到锁，退出或抛出异常时释放锁。

synchronized是通过jvm实现的，jvm是通过monitorenter和monitorexit指令实现的。

monitorenter获得对象锁，monitorexit释放对象锁。对象锁存在于对象头中。

对象头的内容：对象锁信息，

markword：存储对象的hashcode和锁信息。

ClassMetadataAddress：对象的元数据（包括方法表，构造方法，成员变量。。）

arrayLength：数组的长度（如果是数组的话,如果不是数组没有这个)

锁存在于MarkWord中：

锁状态25bit4bit1bit是否是偏向锁2bit锁标志位对象的hashcode对象分代年龄001

各种锁的MarkWord：

轻量级锁指向栈中锁记录的指针00重量级锁指向互斥量（重量级锁）的指针10GC标记11偏向锁线程IDepoch，对象分代年龄101

（2）锁升级

在synchronized中有四种级别的锁：无锁状态，偏向锁状态，轻量级锁状态，重量级锁状态。

锁只能升级，不能降级。

（1）偏向锁：一个锁由一个对象多次获得，为了代价最低，引入了偏向锁

当一个线程获得了无锁状态的锁，那么就会将自己线程ID通过CAS记录进对象头MarkWord中，从无锁升级为偏向锁。

当线程再次获得了锁对象，就检测一下锁对象的对象头的MardWCASDord中的偏向锁是否是自己的线程ID，如果是直接用，如果不是则用CAS修改为自己的线程ID，然后使用。

如果CAS失败次数超过自旋阈值（也就是存在大量竞争），那么就将升级为轻量级锁。

（2）轻量级锁：

jvm现在当前线程的栈中创建用于存储锁记录的空间，并且将对象头中的MarkWord复制到锁记录中，然后线程会尝试用CAS将对象头中的markword替换为指向锁的指针（指向栈的指针），如果成功，当前线程获得锁，如果失败，表示其他进程在竞争锁，当前线程便使用自旋来获得锁。

如果自旋很多次都没有获得锁，那么就会膨胀成重量级锁。

（3）重量级锁

这是一个互斥锁，一旦线程完成了synchronized就会释放锁，其他进程竞争锁。

没有获得锁的进程会进入阻塞，当有锁时候会被唤醒，这会造成上下文切换，造成较大的性能损失。

2。处理器实现原子操作

当存在跨总线宽度，跨多个缓存行和跨页表时候，处理器不能保证其原子性，但是可以提供总线锁定和缓存锁定来保证原子性。

MESI协议

（1）总线锁定：当一个cpu处理时，其他cpu无法访问这个内存。

（2）缓存锁定：使用缓存一致性MESI，使用缓存行时候，其他cpu缓存中的共享缓存行设置为invalied。

3。java实现原子操作

（1）使用循环CAS

缺点：ABA问题，占用cpu使用，只能保证一个原子元素的原子操作。

（2）使用锁

第三章----java内存模型：线程间通信，顺序一致性

java是通过共享内存来实现进程间通信的。

同步是指程序中应用于控制不同进程间操作发生的相对顺序的操作。

对于实例域和静态域和数组是存储在主内存中的，是共享变量，需要从主内存中取出然后放在属于内存的本地内存中。

本地内存并非真实存在，它是cpu缓存，寄存器的抽象概念。

局部变量存在本地内存上。

进程间通信就是通过修改共享变量来实现的。线程修改本地内存，然后刷入主内存。

（1）从源代码到指令代码的重排序

编译器和处理器为了提高效率，会对指令作重排序。

源代码-》编译器优化重排序-》指令级并行重排序-》内存系统重排序-》最终指向的指令序列

这些重排序会导致并行执行发生冲突。

对于编译器级别的重排序，JMM会禁止部分编译器的重排序。

对于处理器级别的重排序，JMM会Java编译器在生成指令序列时候，插入内存屏障，通过内存屏障来实现对处理器重排序的禁止。

JMM（java内存模型）是语言级别的内存模型，它确保在不同编译器和处理器平台上，通过禁止重排序，来实现一致的内存可见性保证。

（2）内存屏障：通过缓存刷入保证，顺序一致性

有四种屏障，只拿StoreLoad Barriers举例。

StoreLoad Barriers : Store 1 ;StoreLoad; Load 2;

确保先将数据保存到主内存，然后加载出到本地内存中（加载出的是新数据）。

执行该屏障花费很大，会将cpu缓存中所有的数据都刷入到内存中（flush）。

（3）happens-before关系：一个偏序关系

happens-before关系代表：前一个执行结果对于u后一个操作可见，且第一个操作在第二个操作之前。

是一种为了对程序员方便的抽象概念。

（4）数据依赖性：后一个操作依赖前一个操作

单线程的数据依赖性，编译器和处理器会自然保证顺序。

对于数据依赖关系的操作，编译器和处理器不会进行重排序。

不管怎样，单线程的执行结果不会被改变，这就是as-if-serial语义。

（5）当单线程happens-before不会影响结果的，会重排序提高并行性。

（6）顺序一致性内存模型：所有进程串行执行

在顺序一致性模型中，操作是全序关系，每个线程都全知整体。

但是JMM没有这个保证，未同步程序整体是无须的，并且线程也不知道彼此之间的执行顺序。

（7）JMM实现同步程序的顺序一致性的相似效果

通过给临界区加锁，临界区内的代码可以重排序（但是不能溢出到临界区外），临界区外的代码也可以重排序。

这种JMM方法，在不改变执行结果的前提下，尽可能地位编译器和处理器的优化开方便之门。

（8）未同步（没有加锁。。）的执行特征

不会保证和顺序一致性内存模型相同的执行结果。

为了实现最小安全性，JVM在分配对象时，首先会对内存空间清零。

1.volatile的内存语义

使用volatile相当于给变量操作都加锁，保证不会中断，而且刷入主内存。

volatile能建立happens-before关系，volatile读写不能重排序，是编译器在生成字节码文件时，在指令序列中插入内存屏障来阻止处理器重排序实现的。

屏障通过刷入主内存来阻止，屏障上下进行重排序。

JMM对于volatile十分保守：在每一个volatile写的后面或读的前面都会插入一个内存屏障。

所有类型的屏障都是通过组织屏障两边重排序实现的。

2.锁的内存语义

临界区：共享资源，可能被多个线程访问。需要同步控制，保证一个时间，只有一个线程访问。

锁的释放--获取建立的happens-before关系。

锁除了让临界区互斥执行外，还可以让释放的锁的线程向获取锁的进程发送消息（保证happens-before）。

实例方法，synchronized在调用的对象上加锁，每个对象实例都能唯一使用，多个对象可以同时执行。

静态方法，在类的class上加锁，只能有一个对象调用。

（1)锁的释放和获取的内存语义

线程获取锁时，线程的本地内存无效，需要去主内存中获取。

线程释放锁时，线程会将本地内存写入主内存。

（2）公平锁和非公平锁都是通过一个volatile变量实现的。

3.final域的内存语义

final：不可变

final类：不可继承

final方法：不可重写

final值：常量

（1）final的重排序规则

禁止将final域的写操作，重排序到构造函数之外。

实现：JMM禁止把final域的写重排序到构造函数之外。编译器会将构造函数返回之前，插入内存屏障，将缓存写入主内存。

（2）作用：

一个对象初始化给其他线程执行，成员变量的初始化可能重排序到返回对象之后，从而导致其他线程检测到了这个引用对象，但是对象的成员变量为0。

而final确保了在引用对象被所有线程可见之前，final域已经在构造函数返回对象之前初始化完成了，其他线程看到的都是初始化后的。

4.happens-before

happens-before时指两个操作之间的执行顺序，可以在一个线程，也可以不在。

程序员不想要重排序，为了容易理解。

而电脑想要重排序，为了效率。

所以JMM：改变结果的重排序被禁止，而不改变结果的被允许。

例如：如果一个锁只会被一个线程访问，那么锁就被消除了。volatile变量也是。

happens-before的规则：

（1）一个线程中，结果串行。

（2）锁解锁后，happens-before随后对锁加锁。

（3）volatile，写happens-before读。

（4）传递性

（5）Thread.start()在这个线程的所有操作之前。

（6）Thread.join()happens-before 这个线程的所有操作。

5.线程安全的初始化

延迟初始化：懒汉模式，用的时候才初始化

但是面对多线程的访问，延迟初始化可能会看到引用对象没有初始化的值。（因为普通变量重排序到了构造函数return之后）。

我们的解决办法是：给初始化加synchronized。（synchronized在进入时会加内存屏障，出去时也会加内存屏障，确保synchronized代码中的操作输入主内存中）相当于成为了一个原子操作。同时保证只有一个线程能创建对象，不会引起多个线程创建的问题。

synchronized static instance getInstance(){
if(instance==null)
instance=new instance;
return instance;
}

但是开销很大。

双重检查锁定方法：

public static Instance getInstance(){
if(instance==nul){
synchronized(this.class){
if(instance==null)
instance=new instance;
}
}
return instance;
}

如果第一次检查不为空就不会执行synchroized的代码，从而减少开支。

但是这是有问题的，第一次检查对象不为空，但是对象还没有初始化完成，这样返回这个对象，会出问题的。（synchronied有内存屏障保证了初始化的完整性，而这个没办法保证）

《》双重检查锁定延迟初始化问题的根源

创建一个对象，其过程可以分解为：

（1）分配空间

（2）初始化

（3）指向这个空间

在单线程中，可以交换2和3，即先指向再初始化，不会影响结果。

所以双重检查延迟初始化的多线程执行过程如下：

（1-a线程）分配instance空间

（2-a线程）设置instance指向分配的空间

（3-b线程）判断instance不为空，访问instance

（4-a线程）初始化instance。

（5-a线程）访问instance。

在知晓了问题根源后，我们的解决方案如下：

（1）不允许指向insatnce空间和初始化instance重排序。

（2）允许重排序，但是保证两个操作不可中断（原子性）。

《1》基于volatile的解决方案

volatile也会在进入和出去之前加内存屏障，所以能保证所有线程看到的都是最新的。

而给instance加上volatile，那么就会在初始化后才能读。

《2》基于类初始化的解决方案

第四章--java并发基础

1.并发与并行

并发是多cpu，并行是时间块轮询。

2.进程状态

new，runnable,blocked(阻塞于锁）,waiting（等被通知唤醒）,time_waiting（超时等待）,terminated

3.Daemon线程

只有当所有非守护线程结束后，才自动结束。

Daemon的finally代码不会执行，不能依靠finally来执行关闭或清理。

4.构造线程

一个新构造的线程对象是由其parent线程来进行空间分配的，以及继承了parent的是否为Daemon，优先级，和加载资源的contextClassLoader和可继承的ThreadLocal，同时还会分配一个唯一的Id来标识这个线程，至此，一个可以运行的线程对象就初始化好了，在堆中等待着运行了。

使用start（）来启动进程。

5.中断：interrupt是进程间通信的一种方式

中断就是一个标识位属性，其他线程的interrupt（），会将其设置为true。

线程通过检查自身是否被中断来进行响应，通过isInterrupute来判断是否被中断。

中断标识为true，程序并不会终止。想要终止需要程序员主动检查标志位，主动终止程序。