随着计算机系统的发展，多任务处理器系统在现代计算机操作系统中已经是一个必不可少的组成部分了。在很多情况下，如果想要避免因计算机的运算速度与它的存储和通信子系统的差距太大而造成的磁盘I/O、网络通信、数据库访问时间太长的问题，就必须去“压榨”处理器的运算能力，让计算机能够同时处理多项任务。并发问题的产生也引起了物理机及虚拟机内存模型的变革。
1. 硬件的效率与一致性
在正式了解Java虚拟机并发相关知识之前，先了解下物理计算机之中的并发问题，物理机对并发的处理方案对虚拟机的实现有相当大的参考意义。
计算机多任务的执行，都不可能只靠处理器的“运算”而完成。其中，处理器至少要与内存交互读取运算数据、存储运算结果，这个I/O操作是很难消除的。然而由于计算机存储设备与处理器的运算速度有几个数量级的差距，所以现代计算机系统中都加入了一层读写速度接近处理器运算速度的高速缓存（Cache）来作为内存与处理器之间的缓冲：将运算要使用到的数据先复制到缓存中，让运算能够更快速的执行，当运算结束后再从缓存中同步回内存之中，从而避免了缓慢的内存读写。同时，这种设计又引入了一个新的问题——缓存一致性问题。在多处理器系统中，每个处理器都有自己的高速缓存，而同时又共享同一主内存，当多个处理器的运算任务都涉及到同一块内存区域时，将可能导致各自的缓存数据不一致。为了解决一致性问题就需要各个处理器在访问缓存时都遵循一些协议。内存模型即在特定的操作协议下，对特定的内存或高速缓存进行读写访问的过程抽象。
处理器、高速缓存、主内存之间的交互关系.png
2. Java 内存模型
Java内存模型的主要目的是定义程序中各个变量的访问规则，即在虚拟机中j将变量存储到内存和从内存中取出变量这样的底层细节。
-
主内存与工作内存
Java内存模型规定了所有的变量都存储在主内存（Main Memory）中，同时每条线程还有自己的工作内存 （Working Memory），线程的工作内存中保存了被该线程使用到的变量的主内存副本拷贝，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存中的变量。不同的线程之间也无法直接访问对方工作内存中的变量，线程间变量值的传递均需要通过主内存来完成。
线程、工作内存、主内存三者的交互关系.png
-
内存间交互操作
Java内存模型中定义了以下8种操作来完成工作内存与主内存之间的交互。
- lock(锁定) ： 作用于主内存的变量，把一个变量标识为一条线程独占的状态。
- unlock(解锁) ： 作用于主内存的变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
- read(读取) ： 作用于主内存的变量，把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用。
- load(载入) ： 作用于工作内存的变量，把read操作所得到的值放入工作内存的变量副本中。
- use(使用) ： 作用于工作内存的变量，把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用到变量的值的字节码指令时将会执行这个操作。
- assign(赋值) ：作用于工作内存的变量，把一个从执行引擎接收到的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
- store(存储) ： 作用于工作内存的变量，把工作内存中一个变量的值传送到主内存中，以便随后的write操作使用。
- write(写入) ： 作用于主内存的变量，把store操作所从工作内存中得到的变量的值放入主内存的变量中。
同时，Java内存模型还规定了在执行上述8种操作时必须满足如下规则：
- 不允许read和load、store和write操作之一单独出现，即不允许一个变量从主内存读取了但工作内存不接受，或者从工作内存发起回写了但主内存不接受的情况。
- 不允许一个线程丢弃它的最近assign操作，即变量在工作内存中改变了之后必须把该变化同步回主内存。
- 不允许一个线程无原因的（没有发生过任何assign操作）把数据从线程的工作内存同步回主内存中。
- 一个新的变量只能在主内存中“诞生”，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量，就是对一个变量执行use和store之前必须先执行过了assign和load操作。
- 一个变量在同一个时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁。
- 如果对一个变量执行lock操作，僵尸清空工作内存中此变量的值，在执行引擎使用这个变量前，需要重新执行load或assign操作初始化变量的值。
- 如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作，也不允许去unlock一个被其他线程锁定住的变量。
- 对一个变量执行unlock操作之前，必须先把此变量同步回主内存中（执行store和write操作）。
-
volatile关键字
volatile关键字是Java虚拟机提供的最轻量级的同步机制，当一个变量被定义成volatile后，它将具备两种特性：
-
保证此变量对所有线程的可见性：
当一条线程修改了这个变量的值，新值对于其他线程来说是可以立即得知的。虽然volatile变量在各个线程中是一致的，但由于Java里面的运算并非原子操作，而导致了volatile变量的运算在并发下一样是不安全的。
public static volatile int value = 0;
private static final int THREAD_COUNT = 20;
public static void increase(){
value ++;
}
public static void main(String[] args) {
Thread [] threads = new Thread[THREAD_COUNT];
for (int i = 0 ; i < THREAD_COUNT ; i++){
threads[i] = new Thread(new Runnable() {
@Override
public void run() {
for(int i = 0 ; i < 1000 ;i ++){
increase();
}
}
});
threads[i].start();
}
while (Thread.activeCount()>2)
// Thread.currentThread().getThreadGroup().list(); 获取当前项目所有线程并输出
Thread.yield();//主线程让出cpu使用权
System.out.println(value);
}
}
输出结果 ：
19372
通过Javap指令反编译代码后可以得到increase()方法的字节码指令：
public static void increase();
descriptor: ()V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=0, args_size=0
0: getstatic #2 // Field value:I
3: iconst_1
4: iadd
5: putstatic #2 // Field value:I
8: return
LineNumberTable:
line 20: 0
line 21: 8
从字节码层面容易来分析并发失败的原因：当getstatic指令把value的值取到操作栈顶时，volatile关键字保证了value的值在此时是正确的，但是在执行iconst_1, iadd这些指令时，其他线程可能已经把race的值加大了，而操作栈顶的值就变成了过期的数据，所以putstatic指令执行后就可能把较小的value值同步回主内存中。
由于volatile变量只能保证可见性，在不符合以下两条规则的运算场景中，我们仍然要通过加锁（使用synchronized或java.util.concurrent中的原子类）来保证原子性：
1）运算结果并不依赖变量的当前值，或者能够确保只有单一的线程修改变量的值。
2）变量不需要与其他的状态变量共同参与不变约束。
-
禁止指令重排序优化：
普通变量仅仅会保证在该方法的执行过程中所有依赖赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操作的顺序与程序代码中的执行顺序一致。因为在一个线程的方法执行过程中无法感知到这点，这也就是Java内存模型中描述的所谓的“线程内表现为串行的语义。
java内存模型中对volatile变量定义的特殊规则：假定T表示一个线程，V和W分别表示volatile型变量，那么在进行read、load、use、assign、store和write操作时需要满足如下规则：
1）只有当线程T对变量V执行的前一个动作为load时，T才能对V执行use；并且，只有T对V执行的后一个动作为use时，T才能对V执行load。T对V的use，可以认为是和T对V的load。read动作相关联，必须连续一起出现（这条规则要求在工作内存中，每次使用V前都必须先从主内存刷新最新的值，用于保证能看见其他线程对V修改后的值）。
2）只有当T对V的前一个动作是assign时，T才能对V执行store；并且，只有当T对V执行的后一个动作是store时，T才能对V执行assign。T对V的assign可以认为和T对V的store、write相关联，必须连续一起出现（这条规则要求在工作内存中，每次修改V后都必须立刻同步回主内存中，用于保证其他线程看到自己对V的修改）。
3）假定动作A是T对V实施的use或assign动作，假定动作F是和动作A相关联的load或store动作，假定动作P是和动作F相应的对V的read或write动作；类似的，假定动作B是T对W实施的use或assign动作，假定动作G是和动作B相关联的load或store动作，假定动作Q是和动作G相应的对W的read或write动作。如果A先于B，那么P先于Q（这条规则要求volatile修饰的变量不会被指令的重排序优化，保证代码的执行顺序与程序的顺序相同）。
-
对long和double型变量的特殊规则
Java内存模型允许虚拟机将没有被volatile修饰的64位数据类型（long和double）的读取操作划分为两次32位的操作来进行，即允许虚拟机实现选择可以不保证64位数据类型的load、store、read和write这4个操作的原子性，就点就是long和double的非原子协定（Nonatomic Treatment of double and long Variables）。
如果多个线程共享一个为声明为volatile的long或double类型变量，并同时对他们进行读取和修改操作，那么有些线程可能会读取到一个即非原值，也不是其他线程修改值得代表了“半个变量”的数值。
不过这种读取带“半个变量”的情况非常罕见（在目前商用虚拟机中不会出现），因为Java内存模型虽然允许虚拟机不把long和double变量的读写实现成原子操作，但允许虚拟机选择把这些操作实现为具有原子性的操作，而且还“强烈建议”虚拟机这样实现。因此我们在编写代码时一般不需要把用到的long和double变量专门声明为volatile。
-
原子性、可见性和有序性
原子性（Atomicity）：由Java内存模型来直接保证的原子性变量操作包括read、load、assign、use、store和write，我们大致可以认为基本数据类型的访问具备原子性（long和double例外），同时我们也可以通过synchronized关键字来保证其中的操作具备原子性。
可见性（Visibility）：指当一个线程修改了共享变量的值，其他线程能够立即得知这个修改。除了volatile，Java还有两个关键字能实现可见性，synchronized和final。同步块的可见性是由“对一个变量执行unlock操作之前，必须把此变量同步回主内存中（执行store和write操作）”这条规则获得的，而final关键字的可见性是指：被final修饰的字段在构造器中一旦被初始化完成，并且构造器没有把“this”的引用传递出去（this引用逃逸是一件很危险的事情，其他线程有可能通过这个引用访问到“初始化了一半”的对象），那么其他线程中就能看见final字段的值。
有序性（Ordering）：Java程序中天然的有序性可以总结为一句话：如果在本线程内观察，所有的操作都是有序的；如果在一个线程中观察另外一个线程，所有的操作都是无序的。前半句是指“线程内表现为串行的语义”（Within-Thread As-if-Serial Semantics），后半句是指“指令重排序”现象和“工作内存与主内存同步延迟”现象。Java语言提供了volatile和synchronized两个关键字来保证线程之间操作的有序性，volatile关键字本身就包含了禁止指令重排序的语义，而synchronized则是由“一个变量在同一时刻只允许一条线程对其进行lock操作”这条规则获得的，这个规则决定了持有同一个锁的两个同步块只能串行地进入。
-
先行发生原则
先行发生是Java内存模型中定义的两项操作之间的偏序关系，如果操作A先行发生于操作B，其实就是说在发生操作B之前，操作A产生的影响能被操作B观察到，“影响”包括修改了内存中共享变量的值/发送了消息/调用了方法等。如下是Java内存模型下一些“天然的”先行发生关系，无须任何同步器协助就已经存在，可直接在编码中使用。如果两个操作之间的关系不在此列，并且无法从下列规则推倒出来，它们就没有顺序性的保障，虚拟机可以对它们进行随意地重排序。
1）程序次序规则（Program Order Rule）：在一个线程内，按照程序代码顺序，书写在前面的操作先行发生于书写在后面的操作。准确地来说应该是控制流顺序而不是程序代码顺序，因为要考虑分支/循环结构。
2）管程锁定规则（Monitor Lock Rule）：一个unlock操作先行发生于后面对同一锁的lock操作。这里必须强调的是同一锁，而“后面”是指时间上的先后顺序。
3）volatile变量规则（Volatile Variable Rule）：对一个volatile变量的写操作先行发生于后面对这个变量的读操作，这里的“后面”是指时间上的先后顺序。
4）线程启动规则（Thread Start Rule）：Thread对象的start()方法先行发生于此线程的每一个动作。
5）线程终止规则（Thread Termination Rule）：线程中的所有操作都先行发生于对此线程的终止检测，我们可以通过Thread.join()方法结束/Thread.isAlive()的返回值等手段检测到线程已经终止执行。
6）线程中断规则（Thread Interruption Rule）：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过Thread.interrupted()方法检测到是否有中断发生。
7）对象终结规则（Finalizer Rule）：一个对象的初始化完成（构造函数执行结束）先行发生于它的finalize()方法的开始。
8）传递性（Transitivity）：如果操作A先行发生于操作B，操作B先行发生于操作C，那么操作A先行发生于操作C。
时间上的先后顺序与先行发生原则之间基本没有太大的关系，所以衡量并发安全问题时不要受时间顺序的干扰，一切必须以先行发生原则为准。
有关happens-before规则的示例具体参考文章：Happens-Before规则 (先行发生原则)
网友评论