1、简单介绍一下JMM
Java 内存模型（Java Memory Model 简称JMM） 是一种抽象的概念，并不真实存在，指一组规则或规范，通过这组规范定义了程序中各个变量的访问方式。java内存模型(JMM)屏蔽掉各种硬件和操作系统的内存访问差异，以实现让java程序在各种平台下都能达到一致的并发效果。
JMM规定：
- 所有的共享变量都存储在主内存中（包括实例变量、类变量，静态变量，但是不包括局部变量，因为局部变量是线程私有的，不存在多线程之间的竞争）
- 每个线程都有自己的工作内存，线程工作内存中保留了被线程使用的共享变量的副本
- 线程对变量的操作（读或者写）都必须在工作内存中完成，不能直接操作主内存
- 不同线程之间不能相互访问对方的工作内存，线程间变量值的传递需要通过主内存完成。
工作内存和主内存的关系图：
2、分析一下共享变量的不可见性问题。
看代码，定义了一个成员变量 falg，一个子线程负责修改flag的值，另外一个子线程根据flag的值判断是否跳出空循环，实际执行结果为下图，可见，线程0对flag的修改并没有影响到线程1；这就是多线程下共享变量的修改会存在不可见性。
原因就是Thread-1一直访问的都是自己本地内存中的flag，而没有从主内存中去更新flag，所以没办法跳出循环。
java
public class TestVolatile {
// 定义一个成员变量
static boolean flag = true;
public static void main(String[] args) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "start");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
flag = false;
System.out.println(Thread.currentThread().getName() + "end");
}).start();
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "start");
while (flag) {
// 空转
}
System.out.println(Thread.currentThread().getName() + "end");
}).start();
}
}3、解决共享变量可见性的两种方式
- volatile关键字
- 加锁
3.1、volatile关键字处理，还是上述代码，只要在flag属性前加一个volatile关键字，就可以了。
3.2、 加锁处理，看代码
线程1赋值修改flag，线程2不断读取flag，可以看到flag被线程1修改后，线程2是可以读取到变化之后的结果的。
java
public class TestVolatile {
// 定义一个成员变量
static boolean flag = true;
static final Object lock = new Object();
public static void main(String[] args) {
test02(lock);
}
private static void test02(Object lock) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "start");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
flag = false;
System.out.println(Thread.currentThread().getName() + "end");
}).start();
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "start");
while (true) {
synchronized (lock) {
if (flag) {
System.out.println("flag = " + flag);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
} else {
System.out.println("flag = " + flag);
break;
}
}
}
System.out.println(Thread.currentThread().getName() + "end");
}).start();
}
}执行结果
4、解决共享变量可见性的原理？
- 加锁：某一个线程进入synchronized代码块后，执行过程如下：线程获得锁，清空工作内存，从主内存中拷贝最新值到工作内存，执行代码，修改后的副本值刷新回主内存，线程释放锁。
- volatile关键字：其实还是工作内存的及时刷新，volatile有以下语义
- 写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值立即刷新回主内存中
- 读一个volatile变量时，JMM会把该线程本地内存设为无效，重新回到主内存中读取最新共享变量。
5、volatile不保证原子性
volatile是不保证原子性操作的。
java
static volatile int count = 0;
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
new Thread(() -> {
for (int j = 0; j < 10000; j++) {
count++;
}
System.out.println(Thread.currentThread().getName() + "==========> count=" + count);
}).start();
}
}如上述代码，定义了一个volatile修饰的int类型变量，启动10个线程去执行++操作，每个线程修改10000次，按理说修改后的值应该为100000，但是每次执行的结果都没有到100000
发生上述问题的原因在于，count++这个操作不是原子性的，他包含三个步骤：
- 从主内存中读取数据导工作内存
- 对工作内存中的数据进行+1操作
- 将工作内存中的数据写会到主内存
假设某一时间，两个线程都执行到了步骤1，读取到的count值是100 ，然后线程1的CPU时间片到了，停止执行，此时2线程继续执行23步骤，将主内存的值修改为101，这个时候线程1继续执行，但是因为1已经执行了，没有重新去主内存中取值，因此执行23操作后，新值为101，然后往主内存修改的值也是101。
解决原子性办法，
1、加锁
java
static final Object lock = new Object();
static volatile int count = 0;
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
new Thread(() -> {
for (int j = 0; j < 10000; j++) {
synchronized (lock){
count++;
}
}
System.out.println(Thread.currentThread().getName() + "==========> count=" + count);
}).start();
}
}
2、使用atomic包 // 底层CAS，不多介绍了。
java
static AtomicInteger a = new AtomicInteger();
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 10; i++) {
new Thread(() -> {
for (int j = 0; j < 10000; j++) {
a.getAndIncrement();
}
System.out.println(Thread.currentThread().getName() + "==========> count=" + a);
}).start();
}
}6、指令重排序介绍。
什么是重排序？为了提高性能，编译器和处理器常常会对指令进行重新排序。一般重排序分为以下三种：编译器优化重排序，指令级并行重排序，内存系统重排序。
重排序就是为了提高处理初度，如下图。
6.1、指令重排序在多线程并发下会产生什么问题？
经典案例，以下代码执行完毕，i 和 j 的值有可能是多少？经过测试，i=0,j=0的情况也会出现！这就是指令重排序导致的问题，
java
import java.util.concurrent.CountDownLatch;
public class T01_Disorder {
private static int x = 0, y = 0;
private static int a = 0, b = 0;
public static void main(String[] args) throws InterruptedException {
for (long i = 0; i < Long.MAX_VALUE; i++) {
x = 0;
y = 0;
a = 0;
b = 0;
CountDownLatch latch = new CountDownLatch(2);
Thread one = new Thread(new Runnable() {
public void run() {
a = 1;
x = b;
latch.countDown();
}
});
Thread other = new Thread(new Runnable() {
public void run() {
b = 1;
y = a;
latch.countDown();
}
});
one.start();
other.start();
latch.await();
String result = "第" + i + "次 (" + x + "," + y + "）";
if (x == 0 && y == 0) {
System.err.println(result);
break;
}
}
}
}7、volatile是怎么保证指令执行顺序的？
jvm级别，识别到volatile关键词，会执行jvm内存屏障，包括 loadload 屏障、storestore 屏障、loadstore屏障、storeload 屏障（其中load是读，store是写）；
a) 会在写之前加 storestore，写之后加storeload，保证在自己写之前完成其他的写，在自己写完之后才能继续其他的读
b) 会在读之后加上loadload 和 loadstore ，保证在自己读完之后其他的才能读，自己读完之后，其他的才能写
8、 Happens Before原则？
简单的说，如果 A Happens Before B ，那么，A的操作对B，都是可见的。
Happens Before模型是由8条具体规则组成的：
- 程序顺序规则：单线程中，每个操作 都 Happens Before 他后面的操作。
- 监视器规则：一个线程解锁， Happens Before 后面线程的加锁
- volatile变量规则：对一个volatile变量的写， Happens Before 对这个volatile的读
- 传递规则：A Happens Before B，B Happens Before C，则 A Happens Before C
- start() 规则：如果线程A执行ThreadB.start()，那么A线程的ThreadB.start()操作 happens-before 线程B的任意操作。
- join() 规则：如果线程A执行ThreadB.join()，那么B线程中的任意操作 happens-before 线程A从ThreadB.join()成功返回。
- 程序中断规则：对线程interrupted()方法的调用 happens-before 被中断线程的代码检测到中断时间的发生；
- 对象finalize规则：一个对象初始化完成（构造函数执行结束）happens-before 于发生它的finalize()方法的开始
9、总结一下volatile关键字的作用
- 保证变量的可见性
- 禁止指令重排序
10、volatile和synchronized的区别？
- 关键字使用范围：volatile只能修饰变量，synchronized关键字能修饰变量，方法，代码块
- 是否会阻塞线程：volatile不会阻塞线程，synchronized会阻塞线程
- 原子性：volatile不保证原子性，synchronized可以保证原子性
- 可见性：volatile 和 synchronized 都可以保证 修改的可见性
- 指令重排序：volatile禁止指令重排序，synchronized允许被编译器优化。
总的来说，volatile的本质是告诉JVM,变量在工作内存（寄存器）中的值是不确定的，需要从主存中去取，synchronized则是直接锁住当前变量，只有当前线程可以访问，其他线程阻塞。