java内存模型定义了主存，工作内存等这些抽象概念，底层对应着cpu寄存器，缓存，cpu指令优化等。
由此引出了 原子性,可见性，有序性
一、原子性
保证指令不会受到上下文切换的影响而产生指令交错，锁就是用来解决这个问题的
二、可见性
为了保证指令不会受cpu缓存的影响
2.1 现象描述和解释
先看一个例子
private final static Logger LOGGER = LoggerFactory.getLogger(Test8.class);
static boolean flag=true;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
while (flag){
}
}
});
t1.start();
Thread.sleep(1000);
LOGGER.info("改变标记");
flag=false;
}
上边的代码t1线程当flag=true时会一直循环,主线程1s后改变flag,按预想的t1应该会结束,实际上t1线程不会结束,
这就是可见性问题。
java内存模型中有主内存，每个线程都有自己的工作内存,当一个变量被频繁读取时,jit编译器会将flag的值缓存到工作内存中的高速缓存中，后边从缓存中读取。这样当主线程修改了flag并更新到主内存后t1线程还是从高速缓存获取flag,所以一直不能停止
总结下来就是一个线程对主内存的数据进行了修改，但对另外一个线程不可见
2.2 解决办法
(1) 给共享的变量加一个关键字volatile,表示容易变化的，这样对这个线程的读取就不会走缓存，一直从工作内存获取。
static volatile boolean flag=true;
(2) synchronized也可以解决可见性问题
获取共享变量值的时候先加锁,这样也能保证可见性
public class Test8 {
private final static Logger LOGGER = LoggerFactory.getLogger(Test8.class);
final static Object lock = new Object();
static boolean flag=true;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
while (true){
synchronized (lock){
if(!flag){
break;
}
}
}
}
});
t1.start();
Thread.sleep(1000);
LOGGER.info("改变标记");
synchronized (lock){
flag=false;
}
}
}
这种解决方式下需要注意对 flag变量的所有操作都要放在synchronized块中
2.3 简单应用
两阶段终止模式可以使用线程的interrupt方法和打断标记来实现，这种方式需要特殊处理InterruptedException
异常，在异常处理中重新设置打断标记,否则就不能正常停止。
也可以使用volatile关键字来实现，这种方式就不需要特殊处理InterruptedException异常了
public class Test2 {
public static void main(String[] args) throws InterruptedException {
Monitor monitor = new Monitor();
monitor.start();
// 2秒后主线程中执行停止
Thread.sleep(3000);
monitor.stop();
}
}
//建设器类，有一个线程一直在监控
class Monitor{
static Logger logger = LoggerFactory.getLogger(Monitor.class);
Thread t;
//控制是否停止的标记
private volatile boolean isStop=false;
//开始监控的方法
public void start(){
t = new Thread(new Runnable() {
@Override
public void run() {
while (true){
Thread current =Thread.currentThread();
// 因为isStop被volatile修饰了,所以其他线程的修改可以感知到，
// 这样就可以用来控制线程是否结束
if(isStop){
//被打断了
logger.debug("要结束了,执行结束前的操作");
break;
}
try {
//每隔一秒执行一次监控逻辑
Thread.sleep(1000);
logger.debug("执行监控逻辑");
} catch (InterruptedException e) {
e.printStackTrace();
//这种方式不需要在异常中进行特殊处理
}
}
}
},"t1");
t.start();
}
//停止监视器的方法
public void stop(){
isStop=true;
}
}
2.4 volatile解决可见性问题的原理
volatile的原理是基于内存屏障,
在读取被volatile修饰的变量时会在读取指令之前加入读屏障,
在写入被volatile修饰的变量时会在写指令之后加入写屏障,
读屏障会保证屏障之后对volatile变量的读取都从主内存中读,写屏障会保证屏障之前对volatile变量的修改都会刷新到主内存中。
三、有序性
保证指令不会受cpu指令并行优化(指令重排)的影响
2.1 问题描述
jit编译器会在不影响最终结果的前提下调整指令的执行顺序，在多线程环境下可能就会出现一些问题。
例如创建对象时，在java层面看到的是一句代码
User user = new User()
在字节码指令层面会对应着几个步骤
(1)创建实例,(2)执行构造方法(3)暴露引用
而 2和3的顺序是有可能被调整的，这样在多线程环境下如果这个user是个共享变量,当前线程有可能先执行了3那么其他线程就有可能拿到一个不完整的对象。
2.2 解决办法
变量用volatile关键字修饰
2.3 volatile解析有序性问题原理
在读取被volatile修饰的变量时会在读取指令之前加入读屏障,
在写入被volatile修饰的变量时会在写指令之后加入写屏障,写屏障会保证之前的指令不进行指令重排。
2.4 有序性应用 多线程单例模式
public class App {
private App(){}
//volatile关键字禁止指令重排
private volatile static App app;
public static App getInstance(){
if(app == null) {
//只有第一次创建对象时才会进入同步块并加锁
synchronized (App.class){
//防止多个线程同时进入了第一个if
if(app == null){
app = new App();
}
}
}
return app;
}
}