谈谈对volatile的理解
volatile是java虚拟机提供的轻量级同步机制，它保证了可见性，不保证原子性，并且禁止指令重排
--JMM内存模型之可见性
JMM本身是一种抽象的概念并不真实存在，它描述的是一组规则或者规范，通过这一组规范定义了程序中的各个变量的访问方式。JMM要求保证可见性，原子性和有序性
JMM关于同步的规定：
- 线程解锁前，必须把共享变量的值刷新回主内存
- 线程加锁前，必须读取主内存的最新值到自己的工作内存
- 加锁解锁是同一把锁
由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存（栈空间），工作内存时每个线程的私有数据区域，而java内存模型中规定所有变量都储存在主内存，主内存是共享内存区域，所有的线程都可以访问，但是线程对变量的操作必须在工作内存中进行，首先要将变量从主内存拷贝到自己的工作内存空间，然后再对变量进行操作，操作完成后再将比变量写回主内存，不能直接操作主内存里的变量，各个线程中的工作内存中储存着主内存中的变量拷贝副本，因此不同的线程无法访问对方的工作内存，线程间的通信必须通过主内存来完成。
所谓可见性就是：当一个线程在本地内存更改了数据并且把变量写回主内存的适合要通知其他线程，现在这个变量已经更改了。
验证可见性的demo
/**
* @ Author wuyimin
* @ Date 2021/9/6-20:47
* @ Description 验证volatile的可见性
*/
public class JMMTest {
public static void main(String[] args) {
//MyData myData = new MyData();
MyDataWithVolatile myData=new MyDataWithVolatile();//添加了可见性任务之后才会打印任务完成
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"进来了");
try{
TimeUnit.SECONDS.sleep(3);
myData.change();
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"更新了值");
},"A").start();
//第二个线程直接使用我们的主线程
while (myData.num==0){}//如果我们不设置可见性那么就会一直在这里自旋导致下面那句话不会打印
System.out.println(Thread.currentThread().getName()+"任务完成");
}
}
//不添加volatile关键字
class MyData{
int num=0;
public void change(){
this.num=60;
}
}
//不添加volatile关键字
class MyDataWithVolatile{
volatile int num=0;
public void change(){
this.num=60;
}
}两种运行结果
?
?volatile不保证原子性
/*
不保证原子性
*/
private static void notProvideAtomicTest() {
MyDataWithVolatile myData = new MyDataWithVolatile();
for (int i = 0; i < 20; i++) {
new Thread(() -> {
for (int j = 0; j < 1000; j++) {
myData.add();//理论上来说保证原子性20个线程加完以后应该就是20000
}
}, "" + i).start();
}
//等待上面的线程计算完成，再使用main线程查看最后结果（这一步不影响定论，但是少了这一步最终结果会大量减少 13452
while (Thread.activeCount() > 2) {
Thread.yield();//线程让步，可以让低于当前优先级的线程优先,
}
System.out.println(myData.num);//19107..每次的值都不一样
}
//添加volatile关键字
class MyDataWithVolatile{
volatile int num=0;
public void change(){
this.num=60;
}
public void add(){
num++;//num++其实有三个操作getfield拿到原始值，iadd执行加一操作，执行putfield把累加后的值写回
}
}?如何不加synchronized来解决？（synchronized过于重量级）
使用包装类AtomicInteger
//不添加volatile关键字
class MyDataWithVolatile {
volatile AtomicInteger atomicNum=new AtomicInteger(0);
public void atomicAdd() {
atomicNum.getAndIncrement();
}
}指令重排：
计算机再执行程序的适合，为了提高性能，编译器和处理器常常会对指令做重排
正常执行时1234，底层重写会考虑数据依赖性可能是2134，1324但是怎么也不会把语句4放到前面。下面给出一个指令重排导致的结果不一致的例子：
单例模式在多线程情况下产生的不安全问题--懒汉式问题改成双重检查锁模式
public class Singleton3 {
private volatile static Singleton3 instance;//防止指令重排，保证可见性，不保证原子性
private Singleton3(){}
public static Singleton3 getInstance(){
if(instance==null){
synchronized (Singleton3.class){
if(instance==null){
instance=new Singleton3();
}
}
}
return instance;
}
}
