可见性与有序性和原子性01

实例：不可见性

volatile：易变关键字

原子性和可见性

问：在之前示例+System.out.println()，会发现不用volatile，线程t1能读取到主内村run变量，原因？

终止模式

打断标记方法：

用volatile方法：

犹豫模式

例子：保证监控线程启动一次

有序性

指令重排：

例子：

利用volatile怎样保证有序性

第二次判断锁的问题：以单例模式为例（懒惰）

解决方案：

happens-before规则

介绍：

第二个规则：

第三个规则：

第四个规则：

第五个规则：

第六个规则：

第七个规则：具有传递性

实例：不可见性

package com.example.juc.JMM;import lombok.extern.slf4j.Slf4j;import static java.lang.Thread.sleep;/*** @author diao 2022/4/13*/
@Slf4j(topic = "c.Test01")
public class Test01 {static boolean run=true;public static void main(String[] args) throws InterruptedException {Thread t1=new Thread(()->{while(run){log.debug("开始跑线程");}},"t1");t1.start();sleep(1);log.debug("开始修改，不能跑了");run=false;log.debug("修改完毕");}
}

每次读取run的值时，后面读取会在自己的工作内存中读取缓存

然后主线程对主内内存的run值进行修改，但是t线程是不知道的——>他读取的还是他的工作内存中的缓存；——>一个线程对值进行修改，另一个线程不知道，造成不可见性

解决一：

volatile：易变关键字

他可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，

必须到主存中获取它的值，volatile变量都是直接操作主存的；

package com.example.juc.JMM;import lombok.extern.slf4j.Slf4j;import static java.lang.Thread.sleep;/*** @author diao 2022/4/13*/
@Slf4j(topic = "c.Test01")
public class Test01 {volatile static boolean run=true;public static void main(String[] args) throws InterruptedException {Thread t1=new Thread(()->{log.debug("准备");while(run){log.debug("Running");}},"t1");t1.start();sleep(1);log.debug("开始修改，不能跑了");run=false;log.debug("修改完毕");}
}

解决二：

用synchronized：它会清理线程中的工作内存，去主存中读取数据；（但是是重量级）

原子性和可见性

synchronized即可以保证原子性又可以保证可见性，和有序性；

volatile一般就是保证可见性和有序性；

场景：像那种代码交错的就是原子性有关，关于锁资源的竞争；

而可见性：是其他线程把变量改了在主内存中，而另一个变量因为读取工作内存所以不知道变量更新，所以要volatile；

问：在之前示例+System.out.println()，会发现不用volatile，线程t1能读取到主内村run变量，原因？

因为里面上了synchronized锁；

终止模式

介绍： 在一个线程中结束另一个线程——>优雅的体现：给第二个线程一个处理后事的机会

优雅如何体现：利用isInterrupt()判断线程打断状态

打断标记方法：

根据current.isInterrupted()线程打断状态进行判断，而线程打断利用：Thread.interrupt()；

package com.example.juc.JMM;import lombok.extern.slf4j.Slf4j;/*** @author diao 2022/4/14*/
@Slf4j(topic = "c.Test02")
public class Test02 {public static void main(String[] args) throws InterruptedException {TwoPhaseTermination tpt = new TwoPhaseTermination();tpt.start();Thread.sleep(2000);log.debug("停止监控");tpt.stop();}}@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination{//监控线程private Thread monitorThread;//启动监控线程public void start(){monitorThread=new Thread(()->{log.debug("进入t1线程");while(true){Thread current = Thread.currentThread();//2.1判断线程是否被打断if(current.isInterrupted()){log.debug("料理后事");break;}try{log.debug("开始睡眠");//2.2睡眠，如果被打断就会进入catch，falseThread.sleep(1000);log.debug("执行监控记录");}catch (InterruptedException e){//2.3打断log.debug("当前线程打断");//打断，改变线程状态为true，后面再次进入循环就会为truecurrent.interrupt();log.debug("当前线程状态[{}]",current.isInterrupted());}}},"monitor");monitorThread.start();}//停止监控线程public void stop(){log.debug("打断");monitorThread.interrupt();}}

用volatile方法：

设置一个变量，一个线程修改变量；

package com.example.juc.Balking;import lombok.extern.slf4j.Slf4j;/*** @author diao 2022/4/14*/
//保证监控线程只启动一次
@Slf4j(topic = "c.Test01")
public class Test01 {/**思路：* 1.设置一个变量用volatile修饰，保证它是主内存中修改，这样就可以给多个线程进行判断要不要做* 2.synchronized对临界区保证原子性*/public static void main(String[] args) throws InterruptedException {final TwoTermination t = new TwoTermination();t.start();Thread.sleep(1000);t.stop();}}@Slf4j(topic = "c.TwoTermination")
class TwoTermination{//1.监控线程private Thread monitorThread;//2.停止标记private volatile boolean stop=false;//3.判断是否执行过start方法,双重验证private volatile boolean starting=false;//4.启动监控线程public void start(){log.debug("开始进入线程");monitorThread=new Thread(()->{//防止虚假修改while(true){//当前线程状态Thread current=Thread.currentThread();//判断是否打断if(stop){log.debug("料理后事");break;}try{log.debug("sleeping..");Thread.sleep(1000);log.debug("执行监控记录");}catch(InterruptedException e){current.interrupt();}}},"monitor");monitorThread.start();}public void stop(){log.debug("开始修改...");stop=true;log.debug("修改完毕...");//打断Monitor线程，状态ifalse，会把sleep后面的执行完monitorThread.interrupt();log.debug("修改线程状态完成{}",monitorThread.isInterrupted());}
}

区别：

Interrupt（）打断，如果是sleep()睡眠时，打断后线程打断状态为false，默认也是false状态，其余状态被打断则为true;

犹豫模式

介绍：Balking模式主要关注的是状态，当线程发现某个对象状态改变了，则会放弃当前工作，比如word文档中编辑的自动保存，比如：需要初始化系统全局资源，一旦初始化，就不再加载，例如单例

(12条消息) 单例模式的思考_Fairy要carry的博客-CSDN博客

Balking：一个线程发现其他线程做了同一件相同的事情，就无需再做，直接结束返回；

核心：volatile

其实本质跟单例模式很像：有其他线程创建了对象，那么就返回之前的对象，保证了对象的唯一性，加快了效率；

例子：保证监控线程启动一次

1.保护代码，变量验证：

当两个线程t1，t2：t1先进入判断为false，但是此时还没有对starting进行更改，然后t2就进来了，判断为false，然后t1再更改starting状态为true，这样明显就拦不住了；

starting+volatile：没有用，该判断什么样还是啥样，只是能取到改变后准确的值；

要用synchronized：等t1线程改完走完再进去（我们最好上双重验证）；——>因为涉及临界区读写操作，要保证原子性；

2.而上面stop+volatile：保证可见性，一个线程修改状态后，另一个线程能拿到；

有序性

指令重排：

多线程下，指令的位置不一样会有明显区别——>比如田忌赛马；

提示：重排列的指令不能影响结果；

如果指令之间有关联，那么指令不能重排序

例子：

第一种：当先执行actor2：num=2，ready=true都执行然后再进入actor1执行时r1=4；

第二种：如果是先num=2，ready还没走完就执行actor1，那么r1=1；

如果指令重排：我们将num=2与ready=true进行位置调换

第三种：那么试想，如果先执行ready=true，然后就直接进入actor1方法中，那么num还是=0，所以r1=0；

因为此时有num=2并没有执行；

解决：在变量前面加一个volatile即可，可以保证之前的变量同步到主内村中；

利用volatile怎样保证有序性

写屏障：写屏障是写前，并且他不会将屏障之前的代码写在屏障之后；

对volatile修饰的变量进行修改，那么屏障之前的，对共享变量的改动都会同步到主存当中；

读屏障：读屏障是读后

对volatile修饰的变量进行读取，会保证读屏障后，对共享变量的读取，加载都是主存中最新数据；

有序性：这个只是保证了当前线程的代码有序性，防止指令重排带来的影响；

第二次判断锁的问题：以单例模式为例（懒惰）

1.当我们对资源上锁，目的是所有线程共用一个对象，所以我们进行上锁

2.但是我们只需要第一次需要：进行互斥判断——>因为之后的进来判断，肯定都!=null，所以只需要第一次上锁就行；

进行修改：先判断是否为空，为空说明是第一次，第一次进去才同步

2. 但还是有问题：因为INSTANCE在外面，也就是其他线程可以拿到INSTANCE变量，

3. 但是这里是有问题的，它可以先赋值，再调用无参构造（之前的是：先调用无参构造，再进行赋值）

这里就会出现一个问题，因为我们锁的是创建对象的区域，而上面INSTANCE并没有锁，所以说，当第一个线程先进行赋值，再还没有调用无参构造的时候，第二个线程加入，进行INSTANCE的判断（这就产生指令交错了，一个以INSTANCE为基准的指令交错），而第二个线程拿到的变量就是没有调用无参构造就赋值的变量，（也就是说出现了重排列现象）；——>创建了，但又和没创建一样，也就是说Instance有内存地址，但是没有被初始化；

t2拿到的就是没有创建好的变量；

解决方案：

我们可以给Instance加volatile，也就是说保证了代码的有序性，防止指令重排——>给写读操作加上了写屏障和读屏障；

写：在我们给Instance赋值的时候就是写操作，之前的读操作（也就是调用构造方法），它不会因为指令重排而到Instance赋值后面，也就是说咋上了一道写屏障；

问：为什么只要把代码块放到synchronized中就可以保证原子性，可见性和有序性呢？

因为所有代码放到synchronized同步代码块中，说明已经是单线程的场景了，就算你是发现了重排序，代码执行的结果也是一样的；

happens-before规则

介绍：

规定了共享变量的写操作对其他线程的读操作是可见的——>(可见性与有序性的一套规则)

因为synchronized会将工作内存清除，所以说读的话是读的主内存中的内容

第二个规则：

volatile：保证了其他线程对变量的读可见

第三个规则：

在线程start前，对变量进行写，因为你这次写是同步到主内存中，你线程一调用第一次肯定是主内存的内容，然后加载到工作内存中——>除非你在线程已经在工作的时候，修改了x的值，这时候由于线程读取的是缓存内存中的内容，所以会造成内容读取不一致；

第四个规则：

当线程结束后，会同步内容

第五个规则：

线程打断前后变量的可见——>t1打断t2前时，对于变量的读可见性以及打断后变量的读可见性；

第六个规则：

对于默认值（0，false，null）的写，其他线程对该变量的读可见；

而默认值指的就是：类加载过程中，准备阶段，赋的默认值；

(12条消息) 类加载机制（一些简单的理解）——阶段性学习_Fairy要carry的博客-CSDN博客

第七个规则：具有传递性

其实只要我们的写操作在读操作前就有读可见，除非你是线程已经读取过该变量了，然后变量被其他线程修改，那么你再读取该变量，就出问题了；

、