Volatile详解

volatile

简介

java虚拟机提供的轻量级的同步机制

1.保证可见性

添加volatile关键词以后,当线程A改变了a的值,那么其它调用a的值其它线

程,就会得到通知

class Mydata{
    volatile int a=0;
    public void resizeA() {
        this.a=60;
    }
}
public class VolatileDemo {
    public static void main(String[] args) {
        Mydata mydata = new Mydata();
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t com in");
            try {
                TimeUnit.SECONDS.sleep(3);//延迟3秒
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            mydata.resizeA();
            System.out.println(Thread.currentThread().getName()+"\t updata number value:"+mydata.a);
        },"aaa").start();
​
        while (mydata.a == 0) {
            //等待
        }
        System.out.println(Thread.currentThread().getName()+"\t over"+mydata.a);
    }
​
}

 

不加volatile 结果1

aaa com in

aaa updata number value:60

不加volatile 线程main 得到的值一直是a=0,所以一直套在死循环中出不来

 

加volatile 结果2

aaa com in

aaa updata number value:60

main over60

加了volatile 线程aaa改了a的值,立马刷新到主内存中去,并通知其它线程

2.不保证原子性

当多个线程同时拿到值后,同时返回到主内存时,一个线程占用了主内存,将值写入,其它线程写主内存,挂起,当通知其它线程时,其它线程就会写进来,从而导致数据损失;

class Mydata{
    volatile int a=0;
    public void resizeA() {
        this.a++;
    }
}
public class VolatileDemo {
    public static void main(String[] args) {
        Mydata mydata = new Mydata();
        for (int i = 0; i < 200; i++) {
            for (int j = 0; j <100 ; j++) {
                new Thread(()->{
                    mydata.resizeA();
                },"aaa").start();
            }
        }
        while (Thread.activeCount() > 2) {//还剩2个,main和gc
            Thread.yield();//让出cpu
        }
        System.out.println(Thread.currentThread().getName()+"\t  "+mydata.a);
    }
​
}

 

计算的数值一定要大,很难发生数据损失

3.禁止指令重排

什么是指令重排?

计算机为了提高性能在执行程序是,编译器和处理器会对程序执行指令重排;

 

指令重排的要求:

1. 单线程的情况下不会改变最终的执行结果

2. 必须考虑数据的依赖性

案例

public class demo{
    int a=0;
    boolean flag=false;
    public void test(){
        a=1;//语句1
        flag=true;//语句2
    }
    //因为没有依赖关系,编译器可能将1和2换位置
    //多线程时,由于速度太快,先执行2,1还没有执行,就执行了test2里面的方法,导致结果无法预测
    public void test2(){
        if(flag){
            a+=5;
           
        }
    }
}

 

volatile的应用案例

单例模式

public class demo{
    int a=0;
    boolean flag=false;
    public void test(){
        a=1;//语句1
        flag=true;//语句2
    }
    //因为没有依赖关系,编译器可能将1和2换位置
    //多线程时,由于速度太快,先执行2,1还没有执行,就执行了test2里面的方法,导致结果无法预测
    public void test2(){
        if(flag){
            a+=5;
           
        }
    }
}

 

synchronized不能禁止指令重排,所以要加volatile来禁止指令重排

因为实例化会发生三个步骤

1.分配内存空间

2.初始化对象

3.指向instance 此时!=null

因为2 3没有数据依赖,所以可能发生指令重排,3先执行,2后,而此时2实际为空对象,所以多线程,在3执行前,使用对象会发生异常;

 

 

拓展:不使用线程锁来实现懒汉单例模式同时保证线程安全

//静态内部类
public class Singleton4 {
    private Singleton4(){}
    private static class Inner{
        private static final Singleton4 INSTANCE=new Singleton4();
    }
    public static Singleton4 getInstance(){
        return Inner.INSTANCE;
    }
}