并发编程之三大特性
一、并发和并行
1.1 并发
并发(concurrency)：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。 
1.2 并行
并行(parallel)：指在同一时刻，有多条指令在多个处理器上同时执行。所以无论从微观还是从宏观来看，二者都是一起执行的。
并行在多处理器系统中存在，而并发可以在单处理器和多处理器系统中都存在，并发能够在单
处理器系统中存在是因为并发是并行的假象，并行要求程序能够同时执行多个操作，而并发只
是要求程序假装同时执行多个操作（每个小时间片执行一个操作，多个操作快速切换执行）。
二、并发三大特性
2.1 可见性
当一个线程修改了共享变量的值，其他线程能够看到修改的值。Java 内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值这种依赖主内存作为传递媒介的方法来实现可见性的。
2.1.1 可见性问题深入分析
我们通过下面的代码来分析Java的多线程可见性的问题
package com.tuling.jucdemo.jmm;
import com.tuling.jucdemo.factory.UnsafeFactory;
import java.util.concurrent.locks.LockSupport;
/**
* 可见性问题深入分析
* -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -Xcomp
* hsdis-amd64.dll
*/
public class VisibilityTest {
// storeLoad JVM内存屏障 ------> (汇编层面指令) lock; addl $0,0(%%rsp)
// lock前缀指令不是内存屏障的指令 但是有内存屏障的效果 缓存失效
//private volatile boolean flag = true;
private volatile boolean flag = true;
//private volatile int count = 0;
//private Integer count = 0;
private int count = 0;
public void refresh(){
flag = false;
System.out.println(Thread.currentThread().getName()+"修改flag:"+flag);
}
public void load(){
System.out.println(Thread.currentThread().getName()+"开始执行......");
while (flag){
//TODO 业务逻辑
count++;
//JMM(Java Memory Model)模型 内存模型: 线程间通信有关 共享内存模型
//可见性方式如下
//1.flag变量前加volatile关键字 可以跳出循环 storeLoad
// JVM内存屏障(汇编层面指令) lock; addl $0, $0(%rsp)
// lock前缀指令不是内存屏障的指令,但是有内存屏障的效果 缓存失效 通过内存屏障实现的
//2.UnsafeFactory.getUnsafe().stoteFence(); 内存屏障 也可也可以跳出循环
// UnsafeFactory.getUnsafe().stoteFence();
//3.Thread.yield(); 可以跳出循环 释放时间片 上下文切换 加载上下文 flag=true
//4.System.out.println(count); println底层由synchronized实现 也是内存屏障 也可以跳出循环
//System.out.println(count);
//5.LockSupport.unpark(Thread.currentThread()); 可以跳出循环
//LockSupport.unpark(Thread.currentThread());
//6.count变量前加volatile关键字 可以跳出循环
//7.private Integer count = 0; 可以跳出循环
//8.showWaite(1000000);//1ms 缓存数据被清理淘汰了(过期了) 可以跳出循环
//showWaite(1000); //1微秒 缓存数据还在不会淘汰 时间太短 不可以跳出循环
//Thread.sleep()也是通过内存屏障
// try {
// Thread.sleep(1000);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
// 总结： java中可见性如何保证？ 方式归类有两种：
//1.jvm层面 storeLoad内存屏障 ===> x86 lock替代了mfence
//2.上下文切换 Thread.yield();
}
System.out.println(Thread.currentThread().getName()+"跳出循环count:"+count);
}
public static void main(String[] args) throws InterruptedException {
VisibilityTest test = new VisibilityTest();
Thread t1 = new Thread(()->test.load(),"t1");
t1.start();
Thread.sleep(1000);
Thread t2 = new Thread(()->test.refresh(),"t2");
t2.start();
}
public static void showWaite(long interval){
long start = System.nanoTime();
long end;
do{
end = System.nanoTime();
}while(interval + start >= end);
}
}
如何保证可见性
1.通过volatile关键字保证可见性。
2.通过内存屏障保证可见性。
3.通过synchronized 关键字保证可见性。
4.通过Lock保证可见性。
5.通过final关键字保证可见性
6.count变量前加Integer，Integer底层源码是final修饰;
2.2 有序性
**即程序执行的顺序按照代码的先后顺序执行。**JVM 存在指令重排，所以存在有序性问题。
2.2.1 有序性问题深入分析
我们通过下面的代码来分析Java的多线程有序性的问题
package com.tuling.jucdemo.jmm;
public class ReOrderTest {
private static int x = 0,y = 0;
private static int a = 0,b = 0;
public static void main(String[] args) throws InterruptedException {
int i = 0;
while(true){
i++;
x = 0;
y = 0;
a = 0;
b = 0;
/**
* x,y: 00,01,10,11
*/
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
shortWait(2000);
a = 1;
x = b; //如果 x = b这句代码在a = 1的上面会出现(0,0)的情况
}
});
Thread t2 = new Thread(new Runnable(){
@Override
public void run() {
b = 1;
y = a;
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("第" + i + "次("+x+","+y+")");
if(x==0 && y==0){
break;
}
}
}
public static void shortWait(long interval ){
long start = System.currentTimeMillis();
long end;
do{
end = System.nanoTime();
}while(start + interval >= end);
}
}
------------------------------------
第67633次(0,1)
第67634次(0,1)
第67635次(0,1)
第67636次(0,1)
第67637次(0,0)
如果在变量a,b前面加上volatile关键字，会一直执行下去
package com.tuling.jucdemo.jmm;
public class ReOrderTest {
private static int x = 0,y = 0;
private volatile static int a = 0,b = 0;
public static void main(String[] args) throws InterruptedException {
int i = 0;
while(true){
i++;
x = 0;
y = 0;
a = 0;
b = 0;
/**
* x,y: 00,01,10,11
*/
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
shortWait(2000);
a = 1;
x = b;
}
});
Thread t2 = new Thread(new Runnable(){
@Override
public void run() {
b = 1;
y = a;
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("第" + i + "次("+x+","+y+")");
if(x==0 && y==0){
break;
}
}
}
public static void shortWait(long interval ){
long start = System.currentTimeMillis();
long end;
do{
end = System.nanoTime();
}while(start + interval >= end);
}
}
JMM内存屏障会出现(0,0)的情况
package com.tuling.jucdemo.jmm;
import com.tuling.jucdemo.factory.UnsafeFactory;
public class ReOrderTest {
private static int x = 0,y = 0;
private static int a = 0,b = 0;
public static void main(String[] args) throws InterruptedException {
int i = 0;
while(true){
i++;
x = 0;
y = 0;
a = 0;
b = 0;
/**
* x,y: 00,01,10,11
*/
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
shortWait(2000);
// storeLoad JMM内存屏障
UnsafeFactory.getUnsafe().storeFence();
x = b;
a = 1;
}
});
Thread t2 = new Thread(new Runnable(){
@Override
public void run() {
UnsafeFactory.getUnsafe().storeFence();
b = 1;
y = a;
}
});
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("第" + i + "次("+x+","+y+")");
if(x==0 && y==0){
break;
}
}
}
public static void shortWait(long interval ){
long start = System.currentTimeMillis();
long end;
do{
end = System.nanoTime();
}while(start + interval >= end);
}
}
--------------------------------------------------
第187次(0,1)
第188次(0,1)
第189次(0,0)
如何保证有序性：
1.通过volatile关键字保证可见性。
2.通过内存屏障保证可见性。
3.通过synchronized关键字保证有序性。
4.通过Lock保证有序性。
2.3 原子性
一个或多个操作，要么全部执行且在执行过程中不被任何因素打断，要么全部不执行。在 Java 中，对基本数据类型的变量的读取和赋值操作是原子性操作（64位处理器）。不采取任何的原子性保障措施的自增操作并不是原子性的。
如何保证原子性：
1.通过synchronized 关键字保证原子性。
2.通过Lock保证原子性。
3.通过CAS保证原子性。
三、Java内存模型(JMM)
3.1 定义
Java虚拟机规范中定义了Java内存模型（Java Memory Model，JMM），用于屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的并发效果，JMM规范了Java虚拟机与计算机内存是如何协同工作的：规定了一个线程如何和何时可以看到由其他线程修改过后的共享变量的值，以及在必须时如何同步的访问共享变量。JMM描述的是一种抽象的概念，一组规则，通过这组规则控制程序中各个变量在共享数据区域和私有数据区域的访问方式，JMM是围绕原子性、有序性、可见性展开的
3.2 JMM与硬件内存架构的关系
Java内存模型与硬件内存架构之间存在差异。硬件内存架构没有区分线程栈和堆。对于硬件，所有的线程栈和堆都分布在主内存中。部分线程栈和堆可能有时候会出现在CPU缓存中和CPU内部的寄存器中。如下图所示，Java内存模型和计算机硬件内存架构是一个交叉关系。
3.3 内存交互操作
关于主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步到主内存之间的实现细节，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操作）。
3.4 JMM的内存可见性保证
按程序类型，Java程序的内存可见性保证可以分为下列3类：
(1).单线程程序。单线程程序不会出现内存可见性问题。编译器、runtime和处理器会共同确保单线程程序的执行结果与该程序在顺序一致性模型中的执行结果相同。
(2).正确同步的多线程程序。正确同步的多线程程序的执行将具有顺序一致性（程序的执行结果与该程序在顺序一致性内存模型中的执行结果相同）。这是JMM关注的重点，JMM通过限制编译器和处理器的重排序来为程序员提供内存可见性保证。
(3).未同步/未正确同步的多线程程序。JMM为它们提供了最小安全性保障：线程执行时读取到的值，要么是之前某个线程写入的值，要么是默认值未同步程序在JMM中的执行时，整体上是无序的，其执行结果无法预知。 JMM不保证未同步程序的执行结果与该程序在顺序一致性模型中的执行结果一致。
未同步程序在JMM中的执行时，整体上是无序的，其执行结果无法预知。未同步程序在两个模型中的执行特性有如下几个差异。
1.顺序一致性模型保证单线程内的操作会按程序的顺序执行，而JMM不保证单线程内的操作会按程序的顺序执行，比如正确同步的多线程程序在临界区内的重排序。
2.顺序一致性模型保证所有线程只能看到一致的操作执行顺序，而JMM不保证所有线程能看到一致的操作执行顺序。
3.顺序一致性模型保证对所有的内存读/写操作都具有原子性，而JMM不保证对64位的long型和double型变量的写操作具有原子性（32位处理器）。
四、volatile的内存语义
4.1 volatile的特性
1.可见性：对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入。
2.原子性：对任意单个volatile变量的读/写具有原子性，但类似于volatile++这种复合操作不具有原子性（基于这点，我们通过会认为volatile不具备原子性）。volatile仅仅保证对单个volatile变量的读/写具有原子性，而锁的互斥执行的特性可以确保对整个临界区代码的执行具有原子性。
64位的long型和double型变量，只要它是volatile变量，对该变量的读/写就具有原子性。
3.有序性：对volatile修饰的变量的读写操作前后加上各种特定的内存屏障来禁止指令重排序来保障有序性。
4.2 volatile写-读的内存语义
1.当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值刷新到主内存。
2.当读一个volatile变量时，JMM会把该线程对应的本地内存置为无效，线程接下来将从主内存中读取共享变量。
4.3 volatile可见性实现原理
JMM内存交互层面实现
volatile修饰的变量的read、load、use操作和assign、store、write必须是连续的，即修改后必须立即同步回主内存，使用时必须从主内存刷新，由此保证volatile变量操作对多线程的可见性。
硬件层面实现
通过lock前缀指令，会锁定变量缓存行区域并写回主内存，这个操作称为“缓存锁定”，缓存一致性机制会阻止同时修改被两个以上处理器缓存的内存区域数据。一个处理器的缓存回写到内存会导致其他处理器的缓存无效。
五、指令重排序
java语言规范规定JVM线程内部维持顺序化语义。即只要程序的最终结果与它顺序化情况的结果相等，那么指令的执行顺序可以与代码顺序不一致，此过程叫指令的重排序。
指令重排序的意义：JVM能根据处理器特性（CPU多级缓存系统、多核处理器等）适当的对机器指令进行重排序，使机器指令能更符合CPU的执行特性，最大限度的发挥机器性能。
在编译器与CPU处理器中都能执行指令重排优化操作
volatile禁止重排序场景：
- 第二个操作是volatile写，不管第一个操作是什么都不会重排序；
- 第一个操作是volatile读，不管第二个操作是什么都不会重排序；
- 第一个操作是volatile写，第二个操作是volatile读，也不会发生重排序。
379
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
