本文来源《深入理解java虚拟机》
多任务处理在现代计算机操作系统中几乎已是一项必备的功能了。让计算机同时去做几件事情,不仅是因为计算机的运算能力强大了,还有一个很重要的原因是计算机的运算速度与它的存储和通信子系统的速度差距太大,大量的时间都花费在磁盘I/O、网络通信或者数据库访问上
。而让计算机同时处理几项任务则是最容易想到,也被证明是非常有效的“压榨”处理器的运算能力的手段。
除了充分利用计算机处理器的能力外,一个服务端要同时对多个客户端提供服务,则是另一个更具体的并发应用场景
。
衡量一个服务性能的高低好坏,每秒事务处理数(Transactions Per Second,TPS)是重要的指标之一,它代表着一秒内服务端平均能响应的请求总数,而TPS值与程序的并发能力又有非常密切的关系。
参考一下物理计算机中的并发问题。物理机遇到的并发问题与虚拟机中的情况有很多相似之处。
绝大多数的运算任务都不可能只靠处理器“计算”就能完成。处理器至少要与内存交互,如读取运算数据、存储运算结果等,这个I/O操作就是很难消除的(无法仅靠寄存器来完成所有运算任务)。
由于计算机的存储设备与处理器的运算速度有着几个数量级的差距,所以现代计算机系统都不得不加入一层或多层读写速度尽可能接近处理器运算速度的高速缓存(Cache)来作为内存与处理器之间的缓冲:
将运算需要使用的数据复制到缓存中,让运算能快速进行,当运算结束后再从缓存同步回内存之中,这样处理器就无须等待缓慢的内存读写了
。
基于高速缓存的存储交互很好地解决了处理器与内存速度之间的矛盾,但它引入了一个新的问题:缓存一致性(Cache Coherence)。
在多路处理器系统中,每个处理器都有自己的高速缓存,而它们又共享同一主内存(Main Memory),这种系统称为共享内存多核系统(Shared Memory Multiprocessors System),如图12-1所示。当多个处理器的运算任务都涉及同一块主内存区域时,将可能导致各自的缓存数据不一致。如果真的发生这种情况,那同步回到主内存时该以谁的缓存数据为准呢?
为了解决一致性的问题,需要各个处理器访问缓存时都遵循一些协议,在读写时要根据协议来进行操作,这类协议有MSI、MESI(Illinois Protocol)、MOSI、Synapse、Firefly及Dragon Protocol等。不同架构的物理机器可以拥有不一样的内存模型,而Java虚拟机也有自己的内存模型。
除了增加高速缓存之外,为了使处理器内部的运算单元能尽量被充分利用,处理器可能会对输入代码进行乱序执行(Out-Of-Order Execution)优化
,处理器会在计算之后将乱序执行的结果重组,保证该结果与顺序执行的结果是一致的
,但并不保证程序中各个语句计算的先后顺序与输入代码中的顺序一致
,因此如果存在一个计算任务依赖另外一个计算任务的中间结果,那么其顺序性并不能靠代码的先后顺序来保证。
与处理器的乱序执行优化类似,Java虚拟机
的即时编译器
中也有指令重排序(Instruction Reorder)优化
。
Java内存模型的主要目的
是定义程序中各种变量值存储到内存和从内存中取出变量值这样的底层细节
。此处的变量
(Variables)与Java编程中所说的变量有所区别,它包括了实例字段、静态字段和构成数组对象的元素
,但是不包括局部变量与方法参数,因为后者是线程私有的,不会被共享
,自然就不会存在竞争问题。
Java内存模型规定了所有的变量都存储在主内存(Main Memory)中
(与绍物理硬件时提到的主内存类比)。
每条线程还有自己的工作内存
(Working Memory,可与前面讲的处理器高速缓存类比),
线程的工作内存中保存了被该线程使用的变量的主内存副本
,线程对变量的所有操作(读取、赋值等)都必须在工作内存中进行,而不能直接读写主内存中的数据。
不同的线程之间也无法直接访问对方工作内存中的变量,线程间变量值的传递均需要通过主内存来完成
。
线程、主内存、工作内存三者的交互关系如图12-2所示,注意与图12-1进行对比。
这里所讲的主内存、工作内存与第2章所讲的Java内存区域中的Java堆、栈、方法区等并不是同一个层次的对内存的划分
,这两者基本上是没有任何关系的。
从变量、主内存、工作内存的定义来看,主内存主要对应于Java堆中的对象实例数据部分
,而工作内存则对应于虚拟机栈中的部分区域
。
主内存直接对应于物理硬件的内存
,而为了获取更好的运行速度,虚拟机(或者是硬件、操作系统本身的优化措施)可能会让工作内存优先存储于寄存器和高速缓存中,因为程序运行时主要访问的是工作内存
。Java虚拟机的即时编译器中也有指令重排序(Instruction Reorder)优化
。
Java内存模型中定义了以下8种操作
来完成一个变量如何从主内存拷贝到工作内存、如何从工作内存同步回主内存这一类的实现细节。
Java虚拟机实现时必须保证下面提及的每一种操作都是原子的、不可再分的。
主内存
的变量,它把一个变量标识为一条线程独占的状态。主内存
的变量,它把一个处于锁定状态的变量释放出来,释放后的变量才可以被其他线程锁定。主内存
的变量,它把一个变量的值从主内存传输到线程的工作内存中,以便随后的load动作使用。主内存
的变量,它把store操作从工作内存中得到的变量的值放入主内存的变量中。工作内存
的变量,它把read操作从主内存中得到的变量值放入工作内存的变量副本中。工作内存
的变量,它把工作内存中一个变量的值传递给执行引擎,每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。工作内存
的变量,它把一个从执行引擎接收的值赋给工作内存的变量,每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。工作内存
的变量,它把工作内存中一个变量的值传送到主内存中,以便随后的write操作使用。如果要把一个变量从主内存拷贝到工作内存,那就要按顺序执行read和load操作,
如果要把变量从工作内存同步回主内存,就要按顺序执行store和write操作。
注意
:Java内存模型只要求上述两个操作必须按顺序执行,但不要求是连续执行。
也就是说read与load之间、store与write之间是可插入其他指令的,如对主内存中的变量a、b进行访问时,一种可能出现的顺序是read a、read b、load b、load a。
除此之外,Java内存模型还规定了在执行上述8种基本操作时必须满足如下规则:
关键字volatile可以说是Java虚拟机提供的最轻量级的同步机制,
当一个变量被定义成volatile之后,它将具备两项特性
:
1.保证此变量对所有线程的可见性
,
volatile型变量的“可见性”是指当一条线程修改了这个变量的值,新值对于其他线程来说是可以立即得知的。
工作内存中,每次使用
volatile型变量V前都必须先从主内存刷新最新的值
,用于保证能看见其他线程对变量V所做的修改
。
每次修改V后
都必须立刻同步回主内存
中,用于保证其他线程可以看到当前线程对变量V所做的修改
。
而普通变量
并不能做到这一点,比如,线程A修改一个普通变量的值,然后向主内存进行回写,若线程B在线程A向主内存回写之前从主内存读取了变量值,那线程B就读到了过期的数据。
注意
:虽然volatile变量对所有线程的可见的
,在各个线程的工作内存中是不存在一致性问题的(从物理存储的角度看,各个线程的工作内存中volatile变量也可以存在不一致的情况,但由于每次使用之前都要先刷新,执行引擎看不到不一致的情况,因此可以认为不存在一致性问题),但是Java里面的运算操作符++并非原子操作,这导致volatile变量的运算在并发下一样是不安全的
,我们可以通过一段简单的演示来说明原因,请看代码清单12-1中演示的例子。
2.是禁止指令重排序优化
,
JVM
会保证在单线程
的情况下,重排序后的执行结果会和重排序之前的结果一致。但是在多线程
的场景下就不一定了。最典型的例子就是标准的双锁检测实现,代码清单12-5 DCL单例模式
volatile是通过在本地代码中插入Lock前缀内存屏障指令来保证处理器不发生乱序执行
(“lock addl$0x0,(%esp)”操作)。
注意:运算操作符的非原子操作和指令重排的区别
?
运算操作符的非原子操作
是指:运算符编译之后,为多条指令,多条指令的执行不是原子操作,在并发情况下,栈顶存的值对应的变量被其他线程修改后,栈顶存的值就是过期的值。
指令重排
:虚拟机不保证执行程序中各个语句计算的先后顺序与输入代码中的顺序一致,但保证该结果与顺序执行的结果是一致的。在并发情况下,若同一段代码中出现几条语句需要顺序执行的原子操作,即可使用volatile型变量来禁止指令重排,保证代码的执行顺序。 如:代码清单12-4
代码清单12-1 volatile的运算
/**
* volatile变量自增运算测试
*
* @author zzm
*/
public class VolatileTest {
public static volatile int race = 0;
public static void increase() {
race++;
}
private static final int THREADS_COUNT = 20;
public static void main(String[] args) {
Thread[] threads = new Thread[THREADS_COUNT];
for (int i = 0; i < THREADS_COUNT; i++) {
threads[i] = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
increase();
}
}
});
threads[i].start();
}
// 等待所有累加线程都结束
while (Thread.activeCount() > 2)
Thread.yield();
System.out.println(race);
}
}
这段代码发起了20个线程,每个线程对race变量进行10000次自增操作,如果这段代码能够正确并发的话,最后输出的结果应该是200000。但每次运行程序,输出的结果都不一样,都是一个小于200000的数字。这是为什么呢?
问题就出在自增运算“race++”之中
,我们用Javap反编译这段代码后会得到代码清单12-2所示,
race++在Class文件中是由4条字节码指令构成(return指令不是由race++产生的,这条指令可以不计算)
,从字节码层面上已经很容易分析出并发失败的原因了:
1.当getstatic指令把race的值取到操作栈顶时,volatile关键字保证了race的值在此时是正确的,但是在执行iconst_1、iadd这些指令的时候,其他线程可能已经把race的值改变了
,而操作栈顶的值就变成了过期的数据
,所以putstatic指令执行后就可能把较小的race值同步回主内存之中。
代码清单12-2 VolatileTest的字节码
public static void increase();
Code:
Stack=2, Locals=0, Args_size=0
0: getstatic #13; //Field race:I
3: iconst_1
4: iadd
5: putstatic #13; //Field race:I
8: return
LineNumberTable:
line 14: 0
line 15: 8
而在像代码清单12-3所示的这类场景中就很适合使用volatile变量来控制并发,当shutdown()方法被调用时,能保证所有线程中执行的doWork()方法都立即停下来
。
代码清单12-3 volatile的使用场景
volatile boolean shutdownRequested;
public void shutdown() {
shutdownRequested = true;
}
public void doWork() {
while (!shutdownRequested) {
// 代码的业务逻辑
}
}
继续通过一个例子来看看为何指令重排序会干扰程序的并发执行。演示程序如代码清单12-4所示。
代码清单12-4 指令重排序
Map configOptions;
char[] configText;
// 此变量必须定义为volatile
volatile boolean initialized = false;
// 假设以下代码在线程A中执行
// 模拟读取配置信息,当读取完成后
// 将initialized设置为true,通知其他线程配置可用
configOptions = new HashMap();
configText = readConfigFile(fileName);
processConfigOptions(configText, configOptions);
initialized = true;
// 假设以下代码在线程B中执行
// 等待initialized为true,代表线程A已经把配置信息初始化完成
while (!initialized) {
sleep();
}
// 使用线程A中初始化好的配置信息
doSomethingWithConfig();
代码清单12-4中所示的程序是一段伪代码,其中描述的场景是开发中常见配置读取过程,只是我们在处理配置文件时一般不会出现并发,所以没有察觉这会有问题。
读者试想一下,如果定义initialized变量时没有使用volatile修饰,就可能会由于指令重排序的优化,导致位于线程A中最后一条代码“initialized=true”被提前执行(这里虽然使用Java作为伪代码,但所指的重排序优化是机器级的优化操作,提前执行是指这条语句对应的汇编代码被提前执行),这样在线程B中使用配置信息的代码就可能出现错误,而volatile关键字则可以避免此类情况的发生。
代码清单12-5 DCL单例模式
public class Singleton {
private volatile static Singleton instance;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
public static void main(String[] args) {
Singleton.getInstance();
}
}
由上可以看到,instance变量被volatile关键字所修饰,但是如果去掉该关键字,就不能保证该代码执行的正确性。这是因为“instance = new Singleton();”这行代码并不是原子操作,其在JVM中被分为如下三个阶段执行:
①为instance分配内存
②初始化instance
③将instance变量指向分配的内存空间
由于JVM可能存在重排序,上述的二三步骤没有依赖的关系,可能会出现先执行第三步,后执行第二步的情况。也就是说可能会出现instance变量还没初始化完成,其他线程就已经判断了该变量值不为null,结果返回了一个没有初始化完成的半成品的情况。而加上volatile关键字修饰后,可以保证instance变量的操作不会被JVM所重排序,每个线程都是按照上述一二三的步骤顺序的执行,这样就不会出现问题。
以上例子的不安全都是由于需要原子操作的不是原子操作带来的,其中需要原子操作的过程如果能被volatile修饰变量的方式,就可以解决如代码清单12-5 DCL单例模式,不能通过被volatile修饰变量的方式解决的如:i++
Java内存模型要求lock、unlock、read、load、assign、use、store、write这八种操作都具有原子性,但是对于64位的数据类型(long和double),在模型中特别定义了一条宽松的规定:允许虚拟机将没有被volatile修饰的64位数据的读写操作划分为两次32位的操作来进行,即允许虚拟机实现自行选择是否要保证64位数据类型的load、store、read和write这四个操作的原子性,这就是所谓的“long和double的非原子性协定”(Non-Atomic Treatment of double and long Variables)。
如果有多个线程共享一个并未声明为volatile的long或double类型的变量,并且同时对它们进行读取和修改操作,那么某些线程可能会读取到一个既不是原值,也不是其他线程修改值的代表了“半个变量”的数值。
在目前主流平台下商用的64位Java虚拟机中并不会出现非原子性访问行为,但是对于32位的Java虚拟机,譬如比较常用的32位x86平台下的HotSpot虚拟机,对long类型的数据确实存在非原子性访问的风险。从JDK 9起,HotSpot增加了一个实验性的参数-XX:+AlwaysAtomicAccesses(这是JEP 188对Java内存模型更新的一部分内容)来约束虚拟机对所有数据类型进行原子性的访问。
而针对double类型,由于现代中央处理器中一般都包含专门用于处理浮点数据的浮点运算器(Floating Point Unit,FPU),用来专门处理单、双精度的浮点数据,所以哪怕是32位虚拟机中通常也不会出现非原子性访问的问题,
由Java内存模型来直接保证的原子性变量操作包括read、load、assign、use、store和write这六个。
如果应用场景需要一个更大范围的原子性保证,Java内存模型还提供了lock和unlock操作来满足这种需求,尽管虚拟机未把lock和unlock操作直接开放给用户使用,但是却提供了更高层次的字节码指令monitorenter和monitorexit来隐式地使用这两个操作。
这两个字节码指令反映到Java代码中就是同步块——synchronized关键字,因此在synchronized块之间的操作也具备原子性。
可见性就是指当一个线程修改了共享变量的值时,其他线程能够立即得知这个修改
。
Java内存模型是通过在变量修改后将新值同步回主内存,在变量读取前从主内存刷新变量值这种依赖主内存作为传递媒介的方式来实现可见性的
,无论是普通变量还是volatile变量都是如此。
普通变量与volatile变量的区别是,
volatile
的特殊规则保证了新值能立即同步到主内存
,以及每次使用前立即从主内存刷新
。因此我们可以说volatile保证了多线程操作时变量的可见性,
而普通变量则不能保证这一点。
除了volatile之外,Java还有两个关键字能实现可见性,它们是synchronized
和final
。
同步块
的可见性是由“对一个变量执行unlock操作之前,必须先把此变量同步回主内存中(执行store、write操作)”这条规则获得的。
而final关键字的可见性是指:被final修饰的字段在构造器中一旦被初始化完成
,并且构造器没有把“this”的引用传递出去(this引用逃逸是一件很危险的事情,其他线程有可能通过这个引用访问到“初始化了一半”的对象),那么在其他线程中就能看见final字段的值
。如代码清单12-7所示,变量i与j都具备可见性,它们无须同步就能被其他线程正确访问。
代码清单12-7 final与可见性
public static final int i;
public final int j;
static {
i = 0;
// 省略后续动作
}
{
// 也可以选择在构造函数中初始化
j = 0;
// 省略后续动作
}
Java语言提供了volatile
和synchronized
两个关键字来保证线程之间操作的有序性
,
volatile关键字本身就包含了禁止指令重排序的语义,
而synchronized则是由“一个变量在同一个时刻只允许一条线程对其进行lock操作”这条规则获得的,这个规则决定了持有同一个锁的两个同步块只能串行地进入。
“先行发生”(Happens-Before)的原则非常重要,它是判断数据是否存在竞争,线程是否安全的非常有用的手段。
依赖这个原则,我们可以通过几条简单规则一揽子解决并发环境下两个操作之间是否可能存在冲突的所有问题,
先行发生是Java内存模型中定义的两项操作之间的偏序关系
,比如说操作A先行发生于操作B,其实就是说在发生操作B之前,操作A产生的影响能被操作B观察到
,“影响”包括修改了内存中共享变量的值、发送了消息、调用了方法等。
如代码清单12-8所示的这三条伪代码。
代码清单12-8 先行发生原则示例1
// 以下操作在线程A中执行
i = 1;
// 以下操作在线程B中执行
j = i;
// 以下操作在线程C中执行
i = 2;
假设线程A中的操作“i=1”先行发生于线程B的操作“j=i”,那我们就可以确定在线程B的操作执行后,变量j的值一定是等于1,得出这个结论的依据有两个:一是根据先行发生原则,“i=1”的结果可以被观察到;二是线程C还没登场,线程A操作结束之后没有其他线程会修改变量i的值。现在再来考虑线程C,我们依然保持线程A和B之间的先行发生关系,而C出现在线程A和B的操作之间,但是C与B没有先行发生关系,那j的值会是多少呢?答案是不确定!1和2都有可能,因为线程C对变量i的影响可能会被线程B观察到,也可能不会,这时候线程B就存在读取到过期数据的风险,不具备多线程安全性。
下面是Java内存模型下一些“天然的”先行发生关系,可以在编码中直接使用。如果两个操作之间的关系不在此列,并且无法从下列规则推导出来,则它们就没有顺序性保障,虚拟机可以对它们随意地进行重排序。
程序次序规则
(Program Order Rule):在一个线程内
,按照控制流顺序,书写在前面的操作先行发生于书写在后面的操作。注意,这里说的是控制流顺序而不是程序代码顺序,因为要考虑分支、循环等结构。
管程锁定规则
(Monitor Lock Rule):一个unlock操作先行发生于后面对同一个锁的lock操作。这里必须强调的是“同一个锁”,而“后面”是指时间上的先后。
·volatile变量规则
(Volatile Variable Rule):对一个volatile变量的写操作先行发生于后面对这个变量的读操作,这里的“后面”同样是指时间上的先后。
·线程启动规则
(Thread Start Rule):Thread对象的start()方法先行发生于此线程的每一个动作。
·线程终止规则
(Thread Termination Rule):线程中的所有操作都先行发生于对此线程的终止检测,我们可以通过Thread::join()方法是否结束、Thread::isAlive()的返回值等手段检测线程是否已经终止执行。
·线程中断规则
(Thread Interruption Rule):对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生,可以通过Thread::interrupted()方法检测到是否有中断发生。
·对象终结规则
(Finalizer Rule):一个对象的初始化完成(构造函数执行结束)先行发生于它的finalize()方法的开始。
·传递性
(Transitivity):如果操作A先行发生于操作B,操作B先行发生于操作C,那就可以得出操作A先行发生于操作C的结论。
Java语言无须任何同步手段保障就能成立的先行发生规则有且只有上面这些,下面演示一下如何使用这些规则去判定操作间是否具备顺序性,对于读写共享变量的操作来说,就是线程是否安全。读者还可以从下面这个例子中感受一下“时间上的先后顺序”与“先行发生”之间有什么不同。演示例子如代码清单12-9所示。
代码清单12-9 先行发生原则示例2
private int value = 0;
pubilc void setValue(int value){
this.value = value;
}
public int getValue(){
return value;
}
代码清单12-9中显示的是一组再普通不过的getter/setter方法,假设存在线程A和B,线程A先(时间上的先后)调用了setValue(1),然后线程B调用了同一个对象的getValue(),那么线程B收到的返回值是什么?
我们依次分析一下先行发生原则中的各项规则。由于两个方法分别由线程A和B调用,不在一个线程中,所以程序次序规则在这里不适用;由于没有同步块,自然就不会发生lock和unlock操作,所以管程锁定规则不适用;由于value变量没有被volatile关键字修饰,所以volatile变量规则不适用;后面的线程启动、终止、中断规则和对象终结规则也和这里完全没有关系。因为没有一个适用的先行发生规则,所以最后一条传递性也无从谈起,因此我们可以判定,尽管线程A在操作时间上先于线程B,但是无法确定线程B中getValue()方法的返回结果,换句话说,这里面的操作不是线程安全的。
那怎么修复这个问题呢?我们至少有两种比较简单的方案可以选择:要么把getter/setter方法都定义为synchronized方法,这样就可以套用管程锁定规则;要么把value定义为volatile变量,由于setter方法对value的修改不依赖value的原值,满足volatile关键字使用场景,这样就可以套用volatile变量规则来实现先行发生关系。
通过上面的例子,我们可以得出结论:一个操作“时间上的先发生”不代表这个操作会是“先行发生”
。
那如果一个操作“先行发生”,是否就能推导出这个操作必定是“时间上的先发生”呢?很遗憾,这个推论也是不成立的。一个典型的例子就是多次提到的“指令重排序”,演示例子如代码清单12-10所示。
代码清单12-10 先行发生原则示例3
// 以下操作在同一个线程中执行
int i = 1;
int j = 2;
代码清单12-10所示的两条赋值语句在同一个线程之中,根据程序次序规则,“int i=1”的操作先行发生于“int j=2”,但是“int j=2”的代码完全可能先被处理器执行,这并不影响先行发生原则的正确性(“int j=2”的代码先行执行,不影响最终结果,可能会由于指令重排导致“int j=2”的代码先执行),因为我们在这条线程之中没有办法感知到这一点。
上面两个例子证明了一个结论:时间先后顺序与先行发生原则之间基本没有因果关系,所以我们衡量并发安全问题的时候不要受时间顺序的干扰,一切必须以先行发生原则为准。
线程是比进程更轻量级的调度执行单位,线程的引入,可以把一个进程的资源分配和执行调度分开,各个线程既可以共享进程资源(内存地址、文件I/O等),又可以独立调度。目前线程是Java里面进行处理器资源调度的最基本单位,
实现线程主要有三种
方式:
使用内核线程
实现(1:1实现),
使用用户线程
实现(1:N实现),
使用用户线程加轻量级进程混合
实现(N:M实现)。
使用内核线程实现的方式也被称为1:1实现。
内核线程(Kernel-Level Thread,KLT)就是直接由操作系统内核(Kernel,下称内核)支持的线程
,这种线程由内核来完成线程切换
,内核通过操纵调度器(Scheduler)对线程进行调度,并负责将线程的任务映射到各个处理器上。每个内核线程可以视为内核的一个分身,这样操作系统就有能力同时处理多件事情,支持多线程的内核就称为多线程内核(Multi-Threads Kernel)。
程序一般不会直接使用内核线程,而是使用内核线程的一种高级接口——轻量级进程(Light Weight Process,LWP),轻量级进程就是我们通常意义上所讲的线程,由于每个轻量级进程都由一个内核线程支持,因此只有先支持内核线程,才能有轻量级进程。这种轻量级进程与内核线程之间1:1的关系称为一对一的线程模型,
如图12-3所示。
优势
:由于内核线程的支持,每个轻量级进程都成为一个独立的调度单元,即使其中某一个轻量级进程在系统调用中被阻塞了,也不会影响整个进程继续工作。
轻量级进程
也具有它的局限性
:
首先,由于是基于内核线程实现的,所以各种线程操作,如创建、析构及同步,都需要进行系统调用
。而系统调用的代价相对较高,需要在用户态(User Mode)和内核态(Kernel Mode)中来回切换
。
其次,每个轻量级进程都需要有一个内核线程的支持
,因此轻量级进程要消耗一定的内核资源(如内核线程的栈空间
),因此一个系统支持轻量级进程的数量是有限的
。
使用用户线程实现的方式被称为1:N实现。
广义
上来讲,一个线程只要不是内核线程,都可以认为是用户线程
(User Thread,UT)的一种,因此从这个定义上看,轻量级进程也属于用户线程,但轻量级进程的实现始终是建立在内核之上的,许多操作都要进行系统调用,因此效率会受到限制,并不具备通常意义上的用户线程的优点
。
而狭义
上的用户线程指的是完全建立在用户空间的线程库上,系统内核不能感知到用户线程的存在及如何实现的
。
用户线程的建立、同步、销毁和调度完全在用户态中完成,不需要内核的帮助
。
如果程序实现得当,这种线程不需要切换到内核态,因此操作可以是非常快速且低消耗的,也能够支持规模更大的线程数量,部分高性能数据库中的多线程就是由用户线程实现的。
这种进程与用户线程之间1:N的关系称为一对多的线程模型,如图12-4所示。
因为使用用户线程实现的程序通常都比较复杂,除了有明确的需求外(譬如以前在不支持多线程的操作系统中的多线程程序、需要支持大规模线程数量的应用),一般的应用程序都不倾向使用用户线程。
还有一种将内核线程与用户线程一起使用的实现方式
,被称为N:M实现。
在这种混合实现下,既存在用户线程,也存在轻量级进程
。
用户线程还是完全建立在用户空间中,因此用户线程的创建、切换、析构等操作依然廉价,并且可以支持大规模的用户线程并发。
而操作系统支持的轻量级进程则作为用户线程和内核线程之间的桥梁,这样可以使用内核提供的线程调度功能及处理器映射,并且用户线程的系统调用要通过轻量级进程来完成,这大大降低了整个进程被完全阻塞的风险。
在这种混合模式中,用户线程与轻量级进程的数量比是不定的,是N:M的关系,如图12-5所示,这种就是多对多的线程模型。
许多UNIX系列的操作系统,如Solaris、HP-UX等都提供了M:N的线程模型实现。在这些操作系统上的应用也相对更容易应用M:N的线程模型。
从JDK 1.3
起,“主流”平台上的“主流”商用Java虚拟机的线程模型普遍都被替换为基于操作系统原生线程模型来实现
,即采用1:1的线程模型。
以HotSpot为例,它的每一个Java线程都是直接映射到一个操作系统原生线程来实现的
,所以HotSpot自己是不会去干涉线程调度的(可以设置线程优先级给操作系统提供调度建议),全权交给底下的操作系统去处理,所以何时冻结或唤醒线程、该给线程分配多少处理器执行时间、该把线程安排给哪个处理器核心去执行等,都是由操作系统完成的,也都是由操作系统全权决定的。
线程调度
是指系统为线程分配处理器使用权的过程,调度主要方式有两种
,分别是协同式
(Cooperative Threads-Scheduling)线程调度和抢占式
(Preemptive Threads-Scheduling)线程调度。
如果使用协同式调度
的多线程系统,线程的执行时间由线程本身来控制,线程把自己的工作执行完了之后,要主动通知系统切换到另外一个线程上去
。
协同式多线程的最大好处
是实现简单
,而且由于线程要把自己的事情干完后才会进行线程切换,切换操作对线程自己是可知的,所以一般没有什么线程同步的问题
。Lua语言中的“协同例程”就是这类实现。
它的坏处
也很明显:线程执行时间不可控制,甚至如果一个线程的代码编写有问题,一直不告知系统进行线程切换,那么程序就会一直阻塞在那里
。
如果使用抢占式调度
的多线程系统,那么每个线程将由系统来分配执行时间,线程的切换不由线程本身来决定
。
譬如在Java中,有Thread::yield()方法可以主动让出执行时间,但是如果想要主动获取执行时间,线程本身是没有什么办法的
。
在这种实现线程调度的方式下,线程的执行时间是系统可控的,也不会有一个线程导致整个进程甚至整个系统阻塞的问题
。
Java使用的线程调度
方式就是抢占式调度
。
Java语言定义了6种线程状态
,在任意一个时间点中,一个线程只能有且只有其中的一种状态,并且可以通过特定的方法在不同状态之间转换。这6种状态分别是:
新建(New)
:创建后尚未启动的线程处于这种状态。
运行(Runnable)
:包括操作系统线程状态中的Running和Ready,也就是处于此状态的线程有可能正在执行,也有可能正在等待着操作系统为它分配执行时间。
无限期等待(Waiting)
:处于这种状态的线程不会被分配处理器执行时间,它们要等待被其他线程显式唤醒。以下方法会让线程陷入无限期的等待状态:
■没有设置Timeout参数的Object::wait()方法;
■没有设置Timeout参数的Thread::join()方法;
■LockSupport::park()方法。
限期等待(Timed Waiting)
:处于这种状态的线程也不会被分配处理器执行时间,不过无须等待被其他线程显式唤醒,在一定时间之后它们会由系统自动唤醒。以下方法会让线程进入限期等待状态:
■Thread::sleep()方法;
■设置了Timeout参数的Object::wait()方法;
■设置了Timeout参数的Thread::join()方法;
■LockSupport::parkNanos()方法;
■LockSupport::parkUntil()方法。
阻塞(Blocked)
:线程被阻塞了,“阻塞状态”与“等待状态”的区别是“阻塞状态”在等待着获取到一个排它锁,这个事件将在另外一个线程放弃这个锁的时候发生;而“等待状态”则是在等待一段时间,或者唤醒动作的发生。在程序等待进入同步区域的时候,线程将进入这种状态。
结束(Terminated
:已终止线程的线程状态,线程已经结束执行。
上述6种状态在遇到特定事件发生的时候将会互相转换,它们的转换关系如图12-6所示。
今天对Web应用的服务要求,不论是在请求数量上
还是在复杂度上
,与十多年前相比已不可同日而语。
现代B/S系统中一次对外部业务请求的响应,往往需要分布在不同机器上的大量服务共同协作来实现,这种服务细分的架构在减少单个服务复杂度、增加复用性的同时,也不可避免地增加了服务的数量,缩短了留给每个服务的响应时间
。
Java目前的并发编程机制就与上述架构趋势产生了一些矛盾,1:1的内核线程模型是如今Java虚拟机线程实现的主流选择
,但是这种映射到操作系统上的线程天然的缺陷是切换、调度成本高昂,系统能容纳的线程数量也很有限
。
以前处理一个请求可以允许花费很长时间在单体应用中,具有这种线程切换的成本也是无伤大雅的,
但现在在每个请求本身的执行时间变得很短、数量变得很多的前提下,用户线程切换的开销甚至可能会接近用于计算本身的开销,这就会造成严重的浪费。
传统的Java Web服务器的线程池的容量通常在几十个到两百之间
,当程序员把数以百万计的请求往线程池里面灌时,系统即使能处理得过来,但其中的切换损耗也是相当可观的。
为什么内核线程调度切换起来成本就要更高?
内核线程的调度成本
主要来自于用户态与核心态之间的状态转换
,而这两种状态转换的开销主要来自于响应中断、保护和恢复执行现场的成本
。
请读者试想以下场景,假设发生了这样一次线程切换:
线程A -> 系统中断 -> 线程B
处理器要去执行线程A的程序代码时,并不是仅有代码程序就能跑得起来,程序是数据与代码的组合体,代码执行时还必须要有上下文数据的支撑。
而这里说的“上下文”,以程序员的角度来看,是方法调用过程中的各种局部的变量与资源;
以线程的角度来看,是方法的调用栈中存储的各类信息;
而以操作系统和硬件的角度来看,则是存储在内存、缓存和寄存器中的一个个具体数值。
物理硬件的各种存储设备和寄存器是被操作系统内所有线程共享的资源,当中断发生,从线程A切换到线程B去执行之前,操作系统首先要把线程A的上下文数据妥善保管好,然后把寄存器、内存分页等恢复到线程B挂起时候的状态,这样线程B被重新激活后才能仿佛从来没有被挂起过。
这种保护和恢复现场的工作,免不了涉及一系列数据在各种寄存器、缓存中的来回拷贝,当然不可能是一种轻量级的操作。
协程的主要优势是轻量
,无论是有栈协程还是无栈协程,都要比传统内核线程要轻量得多。
如果进行量化的话,那么如果不显式设置-Xss或-XX:ThreadStackSize,则在64位Linux上HotSpot的线程栈容量默认是1MB,此外内核数据结构(Kernel Data Structures)还会额外消耗16KB内存。
与之相对的,一个协程的栈通常在几百个字节到几KB之间,所以Java虚拟机里线程池容量达到两百就已经不算小了
,而很多支持协程的应用中,同时并存的协程数量可数以十万计
。
对于有栈协程,有一种特例实现名为纤程(Fiber),这个词最早是来自微软公司,后来微软还推出过系统层面的纤程包来方便应用做现场保存、恢复和纤程调度。OpenJDK在2018年创建了Loom项目,这是Java用来应对本节开篇所列场景的官方解决方案,
Loom项目目前仍然在进行当中,还没有明确的发布日期,
“当多个线程同时访问一个对象时,如果不用考虑这些线程在运行时环境下的调度和交替执行,也不需要进行额外的同步,或者在调用方进行任何其他的协调操作,调用这个对象的行为都可以获得正确的结果,那就称这个对象是线程安全的。”
这里讨论的线程安全,将以多个线程之间存在共享数据访问为前提。
不把线程安全当作一个非真即假的二元排他选项来看待,而是按照线程安全的“安全程度”
由强至弱
来排序,
我们可以将Java语言中各种操作共享的数据
分为以下五类:
不可变、绝对线程安全、相对线程安全、线程兼容和线程对立
。
讲解“final关键字带来的可见性”时曾经提到过这一点:只要一个不可变的对象被正确地构建出来(即没有发生this引用逃逸的情况),那其外部的可见状态永远都不会改变,永远都不会看到它在多个线程之中处于不一致的状态。“不可变”带来的安全性是最直接、最纯粹的。
Java语言中,如果多线程共享的数据
是一个基本数据类型
,那么只要在定义时使用final关键字
修饰它就可以保证它是不可变的
。
如果共享数据是一个对象
,由于Java语言目前暂时还没有提供值类型
的支持,那就需要对象自行保证其行为不会对其状态产生任何影响才行
。
保证对象行为不影响自己状态的途径有很多种
,最简单的一种
就是把对象里面带有状态的变量都声明为final
,这样在构造函数结束之后,它就是不可变的,例如代码清单13-1中所示的java.lang.Integer构造函数,它通过将内部状态变量value定义为final来保障状态不变。
代码清单13-1 JDK中Integer类的构造函数
/**
* The value of the Integer
.
* @serial
*/
private final int value;
/**
* Constructs a newly allocated Integer
object that
* represents the specified int
value.
*
* @param value the value to be represented by the
* Integer
object.
*/
public Integer(int value) {
this.value = value;
}
java.lang.String类的对象实例,它是一个典型的不可变对象
,用户调用它的substring()、replace()和concat()这些方法都不会影响它原来的值,只会返回一个新构造的字符串对象
。
在Java类库API中符合不可变要求的类型,除了上面提到的String之外,常用的还有枚举类型及java.lang.Number的部分子类,如Long和Double等数值包装类型、BigInteger和BigDecimal等大数据类型。
一个类要达到“不管运行时环境如何,调用者都不需要任何额外的同步措施”可能需要付出非常高昂的,甚至不切实际的代价。在Java API中标注自己是线程安全的类,大多数都不是绝对的线程安全
。
java.util.Vector是一个线程安全的容器
,相信所有的Java程序员对此都不会有异议,因为它的add()、get()和size()等方法都是被synchronized修饰的,尽管这样效率不高,但保证了具备原子性、可见性和有序性
。不过,即使它所有的方法都被修饰成synchronized,也不意味着调用它的时候就永远都不再需要同步手段了,请看看代码清单13-2中的测试代码。
代码清单13-2 对Vector线程安全的测试
private static Vector<Integer> vector = new Vector<Integer>();
public static void main(String[] args) {
while (true) {
for (int i = 0; i < 10; i++) {
vector.add(i);
}
Thread removeThread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < vector.size(); i++) {
vector.remove(i);
}
}
});
Thread printThread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < vector.size(); i++) {
System.out.println((vector.get(i)));
}
}
});
removeThread.start();
printThread.start();
//不要同时产生过多的线程,否则会导致操作系统假死
while (Thread.activeCount() > 20);
}
}
运行结果如下:
Exception in thread "Thread-132" java.lang.ArrayIndexOutOfBoundsException:
Array index out of range: 17
at java.util.Vector.remove(Vector.java:777)
at org.fenixsoft.mulithread.VectorTest$1.run(VectorTest.java:21)
at java.lang.Thread.run(Thread.java:662)
尽管这里使用到的Vector的get()、remove()和size()方法都是同步的
,但是在多线程的环境中,如果不在方法调用端做额外的同步措施,使用这段代码仍然是不安全的
。因为如果另一个线程恰好在错误的时间里删除了一个元素,导致序号i已经不再可用,再用i访问数组就会抛出一个ArrayIndexOutOfBoundsException异常。
这里产生异常的原因是,vector.size()之后,确定了i的值,但是vector.size()之后和vector.get(i)之前的这段时间有可能vector中i所在的元素被移除了( vector.remove(i))。由此可见,两个同步方法(vector.size()、vector.get(i))是同步的还不行,还需要这两个方法所在的代码块也是同步的才行
如果要保证这段代码能正确执行下去,我们不得不把removeThread和printThread的定义改成代码清单13-3所示的这样。
代码清单13-3 必须加入同步保证Vector访问的线程安全性
Thread removeThread = new Thread(new Runnable() {
@Override
public void run() {
synchronized (vector) {
for (int i = 0; i < vector.size(); i++) {
vector.remove(i);
}
}
}
});
Thread printThread = new Thread(new Runnable() {
@Override
public void run() {
synchronized (vector) {
for (int i = 0; i < vector.size(); i++) {
System.out.println((vector.get(i)));
}
}
}
});
假如Vector一定要做到绝对的线程安全,那就必须在它内部维护一组一致性的快照访问才行,每次对其中元素进行改动都要产生新的快照,这样要付出的时间和空间成本都是非常大的。
相对线程安全就是我们通常意义上所讲的线程安全,它需要保证对这个对象单次的操作
是线程安全的
,我们在调用的时候不需要进行额外的保障措施,但是对于一些特定顺序的连续调用,就可能需要在调用端使用额外的同步手段来保证调用的正确性
。代码清单13-2和代码清单13-3就是相对线程安全的案例。
在Java语言中,大部分声称线程安全的类都属于这种类型,例如Vector、HashTable、Collections的synchronizedCollection()方法包装的集合等。
线程兼容是指对象本身并不是线程安全的,但是可以通过在调用端正确地使用同步手段来保证对象在并发环境中可以安全地使用。我们平常说一个类不是线程安全的,通常就是指这种情况。Java类库API中大部分的类都是线程兼容的,如与前面的Vector和HashTable相对应的集合类ArrayList和HashMap等。
线程对立是指不管调用端是否采取了同步措施,都无法在多线程环境中并发使用代码。由于Java语言天生就支持多线程的特性,线程对立这种排斥多线程的代码是很少出现的,而且通常都是有害的,应当尽量避免。
一个线程对立的例子是Thread类的suspend()和resume()方法。如果有两个线程同时持有一个线程对象,一个尝试去中断线程,一个尝试去恢复线程,在并发进行的情况下,无论调用时是否进行了同步,目标线程都存在死锁风险——假如suspend()中断的线程就是即将要执行resume()的那个线程,那就肯定要产生死锁了。也正是这个原因,suspend()和resume()方法都已经被声明废弃了。常见的线程对立的操作还有System.setIn()、Sytem.setOut()和System.runFinalizersOnExit()等。
互斥同步
(Mutual Exclusion & Synchronization)是一种最常见也是最主要的并发正确性保障手段。
同步是指在多个线程并发访问共享数据时
,保证共享数据在同一个时刻只被一条(或者是一些,当使用信号量的时候)线程使用
。
而互斥是实现同步的一种手段,临界区(Critical Section)、互斥量(Mutex)和信号量(Semaphore)都是常见的互斥实现方式。
因此在“互斥同步”这四个字里面,互斥是因,同步是果;互斥是方法,同步是目的。
在Java里面,最基本的互斥同步手段就是synchronized
关键字,这是一种块结构(Block Structured)的同步语法
。
synchronized关键字经过Javac编译之后,会在同步块的前后分别形成monitorenter和monitorexit这两个字节码指令
。
这两个字节码指令都需要一个reference类型的参数
来指明要锁定和解锁的对象
。
如果Java源码中的synchronized明确指定了对象参数
,那就以这个对象的引用作为reference
;
如果没有明确指定
,那将根据synchronized修饰的方法类型(如实例方法或类方法)
,来决定是取代码所在的对象实例还是取类型对应的Class对象
来作为线程要持有的锁。
根据《Java虚拟机规范》的要求,在执行monitorenter指令时,首先要去尝试获取对象的锁
。
如果这个对象没被锁定,或者当前线程已经持有了那个对象的锁,就把锁的计数器的值增加一
,
而在执行monitorexit指令时会将锁计数器的值减一
。
一旦计数器的值为零,锁随即就被释放了
。
如果获取对象锁失败,那当前线程就应当被阻塞等待
,直到请求锁定的对象被持有它的线程释放为止。
我们可以得出两个关于synchronized的直接推论,这是使用它时需特别注意的:
被synchronized修饰的同步块
对同一条线程来说是可重入的
。这意味着同一线程反复进入同步块也不会出现自己把自己锁死
的情况。
被synchronized修饰的同步块在持有锁的线程执行完毕并
释放锁之前
,会无条件地阻塞后面其他线程的进入
。这意味着无法像处理某些数据库中的锁那样,强制已获取锁的线程释放锁;也无法强制正在等待锁的线程中断等待或超时退出。
从执行成本的角度看,持有锁是一个重量级(Heavy-Weight)的操作。在第10章中我们知道了在主流Java虚拟机实现中,Java的线程是映射到操作系统的原生内核线程之上的,如果要阻塞或唤醒一条线程,则需要操作系统来帮忙完成,这就不可避免地陷入用户态到核心态的转换中,进行这种状态转换需要耗费很多的处理器时间。尤其是对于代码特别简单的同步块(譬如被synchronized修饰的getter()或setter()方法),状态转换消耗的时间甚至会比用户代码本身执行的时间还要长。因此才说,synchronized是Java语言中一个重量级的操作,
synchronized的局限性,除了synchronized关键字以外,自JDK 5起(实现了JSR 166[1]),Java类库中新提供了java.util.concurrent包(下文称J.U.C包),其中的java.util.concurrent.locks.Lock接口便成了Java的另一种全新的互斥同步手段
。
基于Lock接口,用户能够以非块结构(Non-Block Structured)
来实现互斥同步,从而摆脱了语言特性的束缚,改为在类库层面去实现同步
。
重入锁(ReentrantLock)
是Lock接口最常见的一种实现,顾名思义,它与synchronized一样是可重入的
。
ReentrantLock与synchronized相比增加了一些高级功能
,主要有以下三项
:等待可中断、可实现公平锁及锁可以绑定多个条件。
等待可中断
:是指当持有锁的线程长期不释放锁的时候,正在等待的线程可以选择放弃等待,改为处理其他事情。可中断特性对处理执行时间非常长的同步块很有帮助。
·公平锁
:是指多个线程在等待同一个锁时,必须按照申请锁的时间顺序来依次获得锁;而非公平锁则不保证这一点,在锁被释放时,任何一个等待锁的线程都有机会获得锁。synchronized中的锁是非公平的,ReentrantLock在默认情况下也是非公平的,但可以通过带布尔值的构造函数要求使用公平锁
。不过一旦使用了公平锁
,将会导致ReentrantLock的性能急剧下降
,会明显影响吞吐量。
·锁绑定多个条件
:是指一个ReentrantLock对象可以同时绑定多个Condition对象
。在synchronized中,锁对象的wait()跟它的notify()或者notifyAll()方法配合可以实现一个隐含的条件
,如果要和多于一个的条件关联的时候,就不得不额外添加一个锁;而ReentrantLock则无须这样做,多次调用newCondition()方法即可。
synchronized对性能的影响,尤其在JDK 5之前是很显著的,为此在JDK 6中还专门进行过针对性的优化。当JDK 6中加入了大量针对synchronized锁的优化措施(下一节我们就会讲解这些优化措施)之后,相同的测试中就发现synchronized与ReentrantLock的性能基本上能够持平。
ReentrantLock在功能上是synchronized的超集,在性能上又至少不会弱于synchronized,那synchronized修饰符是否应该被直接抛弃,不再使用了呢?当然不是,基于以下理由,笔者仍然推荐在synchronized与ReentrantLock都可满足需要时优先使用synchronized:
·synchronized是在Java语法层面的同步,足够清晰,也足够简单。每个Java程序员都熟悉synchronized,但J.U.C中的Lock接口则并非如此。因此在只需要基础的同步功能时,更推荐synchronized。
·Lock应该确保在finally块中释放锁,否则一旦受同步保护的代码块中抛出异常,则有可能永远不会释放持有的锁
。这一点必须由程序员自己来保证,而使用synchronized的话则可以由Java虚拟机来确保即使出现异常,锁也能被自动释放。
互斥同步面临的主要问题是进行线程阻塞和唤醒所带来的性能开销,因此这种同步也被称为阻塞同步(Blocking Synchronization)。
从解决问题的方式上看,互斥同步属于一种悲观的并发策略,其总是认为只要不去做正确的同步措施(例如加锁),那就肯定会出现问题,无论共享的数据是否真的会出现竞争,它都会进行加锁(这里讨论的是概念模型,实际上虚拟机会优化掉很大一部分不必要的加锁),这将会导致用户态到核心态转换、维护锁计数器和检查是否有被阻塞的线程需要被唤醒等开销。
随着硬件指令集的发展,我们已经有了另外一个选择:基于冲突检测的乐观并发策略
,
通俗地说就是不管风险,先进行操作,如果没有其他线程争用共享数据,那操作就直接成功了;
如果共享的数据的确被争用,产生了冲突,那再进行其他的补偿措施,最常用的补偿措施是不断地重试,直到出现没有竞争的共享数据为止。
这种乐观并发策略的实现不再需要把线程阻塞挂起,因此这种同步操作被称为非阻塞同步(Non-Blocking Synchronization),使用这种措施的代码也常被称为无锁(Lock-Free)编程。
为什么笔者说使用乐观并发策略需要“硬件指令集的发展”?
因为我们必须要求操作和冲突检测这两个步骤具备原子性
。靠什么来保证原子性?
如果这里再使用互斥同步来保证就完全失去意义了,所以我们只能靠硬件来实现这件事情
,硬件保证某些从语义上看起来需要多次操作的行为可以只通过一条处理器指令就能完成
,这类指令常用的有:
·测试并设置(Test-and-Set);
·获取并增加(Fetch-and-Increment);
·交换(Swap);
·比较并交换(Compare-and-Swap,下文称CAS)
;
·加载链接/条件储存(Load-Linked/Store-Conditional,下文称LL/SC)。
前面的三条是20世纪就已经存在于大多数指令集之中的处理器指令,后面的两条是现代处理器新增的,而且这两条指令的目的和功能也是类似的。
在IA64、x86指令集
中有用cmpxchg指令完成的CAS功能
,在SPARC-TSO中也有用casa指令实现的,
而在ARM和PowerPC架构下
,则需要使用一对ldrex/strex指令来完成LL/SC
的功能。
因为Java里最终暴露出来的是CAS操作,所以我们以CAS指令为例进行讲解。
CAS机制的的解释和总结
CAS指令需要有三个操作数,
分别是内存位置
(在Java中可以简单地理解为变量的内存地址,用V表示)、旧的预期值
(用A表示)和准备设置的新值
(用B表示)。
CAS指令执行时,当且仅当V符合A时,处理器才会用B更新V的值,否则它就不执行更新
。
但是,不管是否更新了V的值,都会返回V的旧值,上述的处理过程是一个原子操作,执行期间不会被其他线程中断
。
在JDK 5之后,Java类库中才开始使用CAS操作
,该操作由sun.misc.Unsafe类里面的compareAndSwapInt()和compareAndSwapLong()等几个方法包装提供。
HotSpot虚拟机在内部对这些方法做了特殊处理,即时编译出来的结果就是一条平台相关的处理器CAS指令
,没有方法调用的过程,或者可以认为是无条件内联进去了。不过由于Unsafe类在设计上就不是提供给用户程序调用的类(Unsafe::getUnsafe()的代码中限制了只有启动类加载器(Bootstrap ClassLoader)加载的Class才能访问它),因此在JDK 9之前只有Java类库可以使用CAS,譬如J.U.C包里面的整数原子类,其中的compareAndSet()和getAndIncrement()等方法都使用了Unsafe类的CAS操作来实现。
而如果用户程序也有使用CAS操作的需求,那要么就采用反射手段突破Unsafe的访问限制,要么就只能通过Java类库API来间接使用它。直到JDK 9之后,Java类库才在VarHandle类里开放了面向用户程序使用的CAS操作。
如何通过CAS操作避免阻塞同步。测试的代码如代码清单12-1所示。这段代码里我们曾经通过20个线程自增10000次的操作来证明volatile变量不具备原子性,那么如何才能让它具备原子性呢?之前我们的解决方案是把race++
操作或increase()方法用同步块包裹起来,这毫无疑问是一个解决方案,但是如果改成代码清单13-4所示的写法,效率将会提高许多。
代码清单13-4 Atomic的原子自增运算
/**
* Atomic变量自增运算测试
*
* @author zzm
*/
public class AtomicTest {
public static AtomicInteger race = new AtomicInteger(0);
public static void increase() {
race.incrementAndGet();
}
private static final int THREADS_COUNT = 20;
public static void main(String[] args) throws Exception {
Thread[] threads = new Thread[THREADS_COUNT];
for (int i = 0; i < THREADS_COUNT; i++) {
threads[i] = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
increase();
}
}
});
threads[i].start();
}
while (Thread.activeCount() > 1)
Thread.yield();
System.out.println(race);
}
}
运行结果如下:
200000
使用AtomicInteger代替int后
,程序输出了正确的结果,这一切都要归功于incrementAndGet()方法的原子性
。
它的实现其实非常简单,incrementAndGet()方法在一个无限循环中,不断尝试将一个比当前值大一的新值赋值给自己
。
如果失败了,那说明在执行CAS操作的时候,旧值已经发生改变,于是再次循环进行下一次操作,直到设置成功为止
。
如代码清单13-5所示。
代码清单13-5 incrementAndGet()方法的JDK源码
/**
* Atomically increment by one the current value.
* @return the updated value
*/
public final int incrementAndGet() {
for (;;) {
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return next;
}
}
尽管CAS
看起来很美好,既简单又高效,但显然这种操作无法涵盖互斥同步的所有使用场景,它存在一个逻辑漏洞
:如果一个变量V初次读取的时候是A值,并且在准备赋值的时候检查到它仍然为A值,那就能说明它的值没有被其他线程改变过了吗?
这是不能的,因为如果在这段期间它的值曾经被改成B,后来又被改回为A,那CAS操作就会误认为它从来没有被改变过。这个漏洞称为CAS操作的“ABA问题”
。
要保证线程安全,也并非一定要进行阻塞或非阻塞同步,如果能让一个方法本来就不涉及共享数据,那它自然就不需要任何同步措施去保证其正确性,因此会有一些代码天生就是线程安全的,笔者简单介绍其中的两类
。
可重入代码(Reentrant Code)
:这种代码又称纯代码(Pure Code),是指可以在代码执行的任何时刻中断它,转而去执行另外一段代码(包括递归调用它本身),而在控制权返回后,原来的程序不会出现任何错误,也不会对结果有所影响。在特指多线程的上下文语境里(不涉及信号量等因素),我们可以认为可重入代码是线程安全代码的一个真子集,这意味着相对线程安全来说,可重入性是更为基础的特性,它可以保证代码线程安全,即所有可重入的代码都是线程安全的,但并非所有的线程安全的代码都是可重入的。
可重入代码有一些共同的特征,例如,不依赖全局变量、存储在堆上的数据和公用的系统资源,用到的状态量都由参数中传入,不调用非可重入的方法等。我们可以通过一个比较简单的原则来判断代码是否具备可重入性:如果一个方法的返回结果是可以预测的,只要输入了相同的数据,就都能返回相同的结果,那它就满足可重入性的要求,当然也就是线程安全的。
线程本地存储(Thread Local Storage)
:如果一段代码中所需要的数据必须与其他代码共享,那就看看这些共享数据的代码是否能保证在同一个线程中执行。如果能保证,我们就可以把共享数据的可见范围限制在同一个线程之内,这样,无须同步也能保证线程之间不出现数据争用的问题。
符合这种特点的应用并不少见,大部分使用消费队列的架构模式(如“生产者-消费者”模式)都会将产品的消费过程限制在一个线程中消费完,其中最重要的一种应用实例就是经典Web交互模型中的“一个请求对应一个服务器线程”(Thread-per-Request)的处理方式,这种处理方式的广泛应用使得很多Web服务端应用都可以使用线程本地存储来解决线程安全问题。
Java语言中,如果一个变量要被多线程访问,可以使用volatile关键字将它声明为“易变的”;
如果一个变量只要被某个线程独享,可以通过java.lang.ThreadLocal类来实现线程本地存储的功能
。
每一个线程的Thread对象中都有一个ThreadLocalMap对象,这个对象存储了一组以ThreadLocal.threadLocalHashCode为键,以本地线程变量为值的K-V值对
,ThreadLocal对象就是当前线程的ThreadLocalMap的访问入口,每一个ThreadLocal对象都包含了一个独一无二的threadLocalHashCode值,使用这个值就可以在线程K-V值对中找回对应的本地线程变量。
互斥同步对性能最大的影响是阻塞的实现,挂起线程和恢复线程的操作都需要转入内核态中完成,这些操作给Java虚拟机的并发性能带来了很大的压力。
在许多应用上,共享数据的锁定状态只会持续很短的一段时间,为了这段时间去挂起和恢复线程并不值得。
现在绝大多数的个人电脑和服务器都是多路(核)处理器系统,如果物理机器有一个以上的处理器或者处理器核心,能让两个或以上的线程同时并行执行,我们就可以让后面请求锁的那个线程“稍等一会”,但不放弃处理器的执行时间,看看持有锁的线程是否很快就会释放锁
。
为了让线程等待,我们只须让线程执行一个忙循环(自旋)
,这项技术就是所谓的自旋锁
,CAS就是自旋。
自旋等待不能代替阻塞,且先不说对处理器数量的要求,自旋等待本身虽然避免了线程切换的开销,但它是要占用处理器时间的,所以如果锁被占用的时间很短,自旋等待的效果就会非常好,反之如果锁被占用的时间很长,那么自旋的线程只会白白消耗处理器资源,而不会做任何有价值的工作,这就会带来性能的浪费。因此自旋等待的时间必须有一定的限度,如果自旋超过了限定的次数仍然没有成功获得锁,就应当使用传统的方式去挂起线程。自旋次数的默认值是十次,用户也可以使用参数-XX:PreBlockSpin来自行更改。
在JDK 6
中对自旋锁的优化,引入了自适应的自旋
。自适应意味着自旋的时间不再是固定的了
,而是由前一次在同一个锁上的自旋时间及锁的拥有者的状态来决定的
。
如果在同一个锁对象上,自旋等待刚刚成功获得过锁,并且持有锁的线程正在运行中,那么虚拟机就会认为这次自旋也很有可能再次成功,进而允许自旋等待持续相对更长的时间,比如持续100次忙循环。另一方面,如果对于某个锁,自旋很少成功获得过锁,那在以后要获取这个锁时将有可能直接省略掉自旋过程,以避免浪费处理器资源。有了自适应自旋,随着程序运行时间的增长及性能监控信息的不断完善,虚拟机对程序锁的状况预测就会越来越精准,虚拟机就会变得越来越“聪明”了。
锁消除是指虚拟机即时编译器在运行时
,对一些代码要求同步
,但是对被检测到不可能存在共享数据竞争的锁
进行消除。
锁消除的主要判定依据来源于逃逸分析的数据支持,如果判断到一段代码中,在堆上的所有数据都不会逃逸出去被其他线程访问到,那就可以把它们当作栈上数据对待,认为它们是线程私有的,同步加锁自然就无须再进行。
变量是否逃逸,对于虚拟机来说是需要使用复杂的过程间分析才能确定的,但是程序员自己应该是很清楚的,怎么会在明知道不存在数据争用的情况下还要求同步呢?这个问题的答案是:有许多同步措施并不是程序员自己加入的,同步的代码在Java程序中出现的频繁程度也许超过了大部分读者的想象。我们来看看如代码清单13-6所示的例子,这段非常简单的代码仅仅是输出三个字符串相加的结果,无论是源代码字面上,还是程序语义上都没有进行同步。
代码清单13-6 一段看起来没有同步的代码
public String concatString(String s1, String s2, String s3) {
return s1 + s2 + s3;
}
我们也知道,由于String是一个不可变的类,对字符串的连接操作总是通过生成新的String对象来进行的,因此Javac编译器会对String连接做自动优化。在JDK 5之前,字符串加法会转化为StringBuffer对象的连续append()操作,在JDK 5及以后的版本中,会转化为StringBuilder对象的连续append()操作。即代码清单13-6所示的代码可能会变成代码清单13-7所示的样子。
代码清单13-7 Javac转化后的字符串连接操作
public String concatString(String s1, String s2, String s3) {
StringBuffer sb = new StringBuffer();
sb.append(s1);
sb.append(s2);
sb.append(s3);
return sb.toString();
}
现在大家还认为这段代码没有涉及同步吗?每个StringBuffer.append()方法中都有一个同步块,锁就是sb对象。虚拟机观察变量sb,经过逃逸分析后会发现它的动态作用域被限制在concatString()方法内部。也就是sb的所有引用都永远不会逃逸到concatString()方法之外,其他线程无法访问到它,所以这里虽然有锁,但是可以被安全地消除掉。在解释执行时这里仍然会加锁,但在经过服务端编译器的即时编译之后,这段代码就会忽略所有的同步措施而直接执行。
如果一系列的连续操作都对同一个对象反复加锁和解锁,甚至加锁操作是出现在循环体之中的,那即使没有线程竞争,频繁地进行互斥同步操作也会导致不必要的性能损耗。
代码清单13-7所示连续的append()方法就属于这类情况。如果虚拟机探测到有这样一串零碎的操作都对同一个对象加锁,将会把加锁同步的范围扩展(粗化)到整个操作序列的外部,以代码清单13-7为例,就是扩展到第一个append()操作之前直至最后一个append()操作之后,这样只需要加锁一次就可以了。
轻量级锁
是JDK 6时加入
的新型锁机制,它名字中的“轻量级”
是相对于使用操作系统互斥量
来实现的传统锁
而言的,因此传统的锁机制就被称为“重量级”锁。
不过,需要强调一点,轻量级锁并不是用来代替重量级锁的,它设计的初衷是在没有多线程竞争的前提下,减少传统的重量级锁使用操作系统互斥量产生的性能消耗
。
要理解轻量级锁,以及后面会讲到的偏向锁的原理和运作过程,必须要对HotSpot虚拟机对象的内存布局(尤其是对象头部分)有所了解。HotSpot虚拟机的对象头(Object Header)分为两部分,第一部分用于存储对象自身的运行时数据,如哈希码(HashCode)、GC分代年龄(Generational GC Age)等。这部分数据的长度在32位和64位的Java虚拟机中分别会占用32个或64个比特,官方称它为“Mark Word”。这部分是实现轻量级锁和偏向锁的关键。另外一部分用于存储指向方法区对象类型数据的指针,如果是数组对象,还会有一个额外的部分用于存储数组长度。
由于对象头信息是与对象自身定义的数据无关的额外存储成本,考虑到Java虚拟机的空间使用效率,Mark Word被设计成一个非固定的动态数据结构,以便在极小的空间内存储尽量多的信息。它会根据对象的状态复用自己的存储空间。例如在32位的HotSpot虚拟机中,对象未被锁定的状态下,Mark Word的32个比特空间里的25个比特将用于存储对象哈希码,4个比特用于存储对象分代年龄,2个比特用于存储锁标志位,还有1个比特固定为0(这表示未进入偏向模式)。对象除了未被锁定的正常状态外,还有轻量级锁定、重量级锁定、GC标记、可偏向等几种不同状态
轻量级锁的工作过程
:在代码即将进入同步块的时候,如果此同步对象没有被锁定(锁标志位为“01”状态),虚拟机首先将在当前线程的栈帧中建立一个名为锁记录(Lock Record)的空间,用于存储锁对象目前的Mark Word的拷贝(官方为这份拷贝加了一个Displaced前缀,即Displaced Mark Word),这时候线程堆栈与对象头的状态如图13-3所示。
上面描述的是轻量级锁的加锁过程,它的解锁过程也同样是通过CAS操作来进行的,如果对象的Mark Word仍然指向线程的锁记录,那就用CAS操作把对象当前的Mark Word和线程中复制的Displaced Mark Word替换回来。假如能够成功替换,那整个同步过程就顺利完成了;如果替换失败,则说明有其他线程尝试过获取该锁,就要在释放锁的同时,唤醒被挂起的线程。
轻量级锁能提升程序同步性能的依据是“对于绝大部分的锁,在整个同步周期内都是不存在竞争的”这一经验法则。如果没有竞争,轻量级锁便通过CAS操作成功避免了使用互斥量的开销;但如果确实存在锁竞争,除了互斥量的本身开销外,还额外发生了CAS操作的开销。因此在有竞争的情况下,轻量级锁反而会比传统的重量级锁更慢。
偏向锁也是JDK 6中引入的一项锁优化措施
,它的目的
是消除数据在无竞争情况下的同步原语
,进一步提高程序的运行性能。
如果说轻量级锁是在无竞争的情况下使用CAS操作去消除同步使用的互斥量
,那偏向锁就是在无竞争的情况下把整个同步都消除掉,连CAS操作都不去做了
。
偏向锁中的“偏”,就是偏心的“偏”、偏袒的“偏”。它的意思是这个锁会偏向于第一个获得它的线程,如果在接下来的执行过程中,该锁一直没有被其他的线程获取,则持有偏向锁的线程将永远不需要再进行同步。
假设当前虚拟机启用了偏向锁(启用参数-XX:+UseBiased Locking,这是自JDK 6起HotSpot虚拟机的默认值),那么当锁对象第一次被线程获取的时候,虚拟机将会把对象头中的标志位设置为“01”、把偏向模式设置为“1”,表示进入偏向模式。同时使用CAS操作把获取到这个锁的线程的ID记录在对象的Mark Word之中。如果CAS操作成功,持有偏向锁的线程以后每次进入这个锁相关的同步块时,虚拟机都可以不再进行任何同步操作(例如加锁、解锁及对Mark Word的更新操作等)。
一旦出现另外一个线程去尝试获取这个锁的情况,偏向模式就马上宣告结束。根据锁对象目前是否处于被锁定的状态决定是否撤销偏向(偏向模式设置为“0”),撤销后标志位恢复到未锁定(标志位为“01”)或轻量级锁定(标志位为“00”)的状态,后续的同步操作就按照上面介绍的轻量级锁那样去执行。偏向锁、轻量级锁的状态转化及对象Mark Word的关系如图13-5所示。
当对象进入偏向状态的时候,Mark Word大部分的空间(23个比特)都用于存储持有锁的线程ID了,这部分空间占用了原有存储对象哈希码的位置,那原来对象的哈希码怎么办呢?
在Java语言里面一个对象如果计算过哈希码,就应该一直保持该值不变(强烈推荐但不强制,因为用户可以重载hashCode()方法按自己的意愿返回哈希码),否则很多依赖对象哈希码的API都可能存在出错风险。而作为绝大多数对象哈希码来源的Object::hashCode()方法,返回的是对象的一致性哈希码(Identity Hash Code),这个值是能强制保证不变的,它通过在对象头中存储计算结果来保证第一次计算之后,再次调用该方法取到的哈希码值永远不会再发生改变。因此,当一个对象已经计算过一致性哈希码后,它就再也无法进入偏向锁状态了
(?此处没懂);而当一个对象当前正处于偏向锁状态,又收到需要计算其一致性哈希码请求[1]时,它的偏向状态会被立即撤销,并且锁会膨胀为重量级锁。在重量级锁的实现中,对象头指向了重量级锁的位置,代表重量级锁的ObjectMonitor类里有字段可以记录非加锁状态(标志位为“01”)下的Mark Word,其中自然可以存储原来的哈希码。
偏向锁可以提高带有同步但无竞争的程序性能,但它同样是一个带有效益权衡(Trade Off)性质的优化,也就是说它并非总是对程序运行有利。如果程序中大多数的锁都总是被多个不同的线程访问,那偏向模式就是多余的。在具体问题具体分析的前提下,有时候使用参数-XX:-UseBiasedLocking来禁止偏向锁优化反而可以提升性能。