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,程序并不会终止。想要终止需要程序员主动检查标志位,主动终止程序。