上次说到Java线程并不会直接操作共享内存，而是操作共享内存的副本，这种方式称作JMM模型，描述的是Java多线程和内存之间的通信。我们上次使用了HotSpot虚拟机的内存模型进行理解，但JMM模型并不是JVM的内存模型，两者都是一种规范，各个虚拟机都有不同的实现方式，JMM模型模仿的是CPU缓存模型
真正的JMM模型如下：
JMM模型
Java中每个线程都有自己独立的工作内存，存在主内存中的共享变量对所有线程都是可见的，即每个线程都能操作它，而实际上线程操作共享变量时会把它拷贝到自己的工作内存中，真正操作的是共享变量的副本，操作结束后，再写入到主内存的共享变量中
缺点：这就会导致如果两个不同的线程同时对一个共享变量操作时，出现不同步的问题，这也是Java并发的三大特性：原子性、可见性、有序性
一、八种原子操作
还记得之前使用javap命令反转义的字节码么？字节码中会将我们方法中写的代码进行细分，成为”iload、istore“等汇编指令，我们一句代码，可能会被分成很多个小的指令。同样的，JMM规定线程对共享变量的操作细分为八种，而这八种操作再也细分不了了，所以称之为原子操作
前六种原子操作为：
- read：从共享变量中读取变量的数据
- load：将读取的数据放入工作内存的副本中
- use：将副本的数据交由执行引擎处理
- assign：将执行结果赋值到副本
- store：从副本中读取数据
- write：将读取数据写回共享变量
结合我们上面JMM模型，如下图：
原子操作共享变量
这就是为什么多个线程对同一个对象同时进行数据操作时，会出现问题的原因：我们的数据还没来得及写回，其他线程就已经在使用它了
另外两种原子操作就是为了解决这个并发问题而出现的：
- lock：对共享变量进行加锁，其他线程只能进入等待队列
- unlock：对共享变量进行解锁，其他线程进行竞争，获取锁对共享变量再次加锁的线程才能进入可执行状态
二、可见性问题
首先看下面的代码：
public class VolatileTest {
public static boolean isRunning = true;
public static void main(String[] args) {
new Thread() {
@Override
public void run() {
try {
sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("isRunning:" + isRunning);
isRunning = false;
System.out.println("isRunning:" + isRunning);
}
}.start();
while (isRunning) {
}
System.out.println("主线程退出");
}
}
主线程先进入while循环，另一个线程200ms后，对isRunning赋值为false，可运行的结果并没有合我们的意，主线程一直在while循环中
原因：
主线程一直在对isRunning变量的副本做判断，而主线程的isRunning变量副本存的值，在最初读取isRunning变量时就是true，虽然另一个线程对isRunning进行了操作，并且也成功的将false写入到了变量中，但是线程的工作内存是私有的，主线程并不知道isRunning发生了改变**，所以主线程中的副本一直都是true，循环并不会退出
共享变量对所有线程都可见，但线程工作内存中是私有的，里面的副本对外不可见
可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
解决方法：
volatile关键字
我们对上面的isRunning变量使用volatile关键字修饰后再运行：
public class VolatileTest {
public static volatile boolean isRunning = true;
public static void main(String[] args) {
new Thread() {
@Override
public void run() {
try {
sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("isRunning:" + isRunning);
isRunning = false;
System.out.println("isRunning:" + isRunning);
}
}.start();
while (isRunning) {
}
System.out.println("主线程退出");
}
}
结果是可以正常退出了
原理：
缓存一致性协议中的MESI协议
MESI协议解决了可见性问题，它将变量分成四种状态：
- M：修改
- E：独占
- S：共享
- I ：失效
使用volatile修饰变量后，该变量就会遵循这种协议，细化步骤为：
1.当执行isRunning = false时，将isRunning设为独占状态，其他线程不能访问
2.修改结束后，写回isRunning，又使它成为共享状态，其他线程可以访问
3.发送数据改变消息给总线嗅探机制
4.其他线程通过总线嗅探机制接收到消息后，将副本设为失效状态
5.副本失效后，重新read load操作，读取数据到副本
上诉代码使用图解如下：
1.主线程读取共享变量：
2.其他线程改变共享变量得值：
3.触发总线嗅探机制：
三、有序性问题
先看下面代码：
package thread;
//解决有序性问题
public class VolatileTest2 {
static int x = 0;
static int y = 0;
static int a = 0;
static int b = 0;
public static void main(String[] args) {
for (int i = 0; i < 10000; i++) {
x = 0;
y = 0;
a = 0;
b = 0;
new Thread(new Runnable() {
@Override
public void run() {
x = a;
b = 1;
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
y = b;
a = 1;
}
}).start();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (x == 1 && y == 1) {
System.out.println("指令重排序出现的问题");
}
}
}
}
按照正常逻辑顺序来看这块代码的话，x和y是不可能同时为1的
因为如果x为1，那么第二个线程的代码肯定执行完了，也就是y = b执行过了，此时b为0，y就一定是0
反之，y为1，x = a已经执行过了，此时a为0，x就一定是0
执行结果还是没合我们的意：
原因：
指令重排序：当一个线程中的两条代码完全不相干时，那么它们的执行顺序是可以交换的
我们以第一个线程为例子： x = a 和 b = 1 没有关联性，那么执行时，它们的顺序不一定按照我们代码所写的顺序执行，如果我们写成：a = 1 和 x = a ，那么它们会按照代码顺序执行
但是在多线程中，这就会造成问题了，由于抢占式线程调度，你不知道何时哪个线程会暂停，哪个线程会执行
解决方法：
volatile关键字修饰这些变量后，再次执行
package thread;
//解决有序性问题
public class VolatileTest2 {
static volatile int x = 0;
static volatile int y = 0;
static volatile int a = 0;
static volatile int b = 0;
public static void main(String[] args) {
for (int i = 0; i < 10000; i++) {
x = 0;
y = 0;
a = 0;
b = 0;
new Thread(new Runnable() {
@Override
public void run() {
x = a;
b = 1;
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
y = b;
a = 1;
}
}).start();
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (x == 1 && y == 1) {
System.out.println("指令重排序出现的问题");
}
}
}
}
这次就不会出现指令重排序了
volatile关键字不仅可以解决可见性问题，还能解决有序性问题，它就是将变量的写操作先行于读操作
四、原子性问题
先来看下面代码：
package thread;
public class VolatileTest3 {
static int count = 0;
public static void main(String[] args) {
for (int i = 0; i < 20000; i++) {
new Thread(){
@Override
public void run() {
addCount();
System.out.println(count);
super.run();
}
}.start();
}
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void addCount() {
count++;
}
}
我们开启了20000次线程，对一个整型变量进行++操作，期望结果为20000，最后执行结果为：
我们继续使用volatile修饰变量，再次执行：
解决方法：
synchronized关键字修饰方法：
package thread;
public class VolatileTest3 {
static int count = 0;
public static void main(String[] args) {
for (int i = 0; i < 20000; i++) {
new Thread() {
@Override
public void run() {
addCount();
System.out.println(count);
super.run();
}
}.start();
}
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static synchronized void addCount() {
count++;
}
}
执行结果：
volatile失效的原因：
虽然通过嗅探机制，副本更新到最新值，但是此时操作引擎已经use了旧的副本，最后assign回副本时，就出现了少加一次1的情况
网友评论