volatile用法

标签：问题   ret   现在   不为   一个   try   OLE   例子   导致   

并发：多个线程访问同一份资源。

并行：一边听歌一边写论文就是并行，同时做事。

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

voliatile有三大特性：

1.保证可见性。

2.不保证原子性。

3.禁止指令重排。

JMM(Java内存模型 Java Memory Model)本身是一种抽象的概念并不真实存在，它描述的是一组规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。

JMM关于同步的规定：

1.线程解锁前，必须把共享变量的值刷新回主内存

2.线程加锁前，必须读取主内存的最新值到自己的工作内存。

3.加锁解锁是同一把锁。

由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存（有些地方称为栈空间），工作内存是每个线程的私有数据区域，而Java内存模型中规定所有变量都存储在主内存，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作（读取赋值等）必须在工作内存中进行，首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，各个线程中的工作内存中存储主内存的变量副本拷贝，因此不同的线程间无法访问对方的工作内存，线程间的通信（传值）必须通过主内存来完成。

JMM的三大特性：

1.可见性。

2.原子性。

3.有序性。

volatile可见性代码例子：

class MyData {
    volatile int number = 0;
    public void add() {
        this.number =60;
    }
}

/**
 * 验证volatile的可见性,如果number不用volatile修饰，那么main线程将死循环，因为volatile具有可见性，可以及时通知其他线程主内存的值已经修改
 */
public class VolatileDemo {
    public static void main(String[] args) {
        MyData myData = new MyData();
        new Thread(() ->{
            System.out.println(Thread.currentThread().getName()+"\t come in number = " + myData.number);
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myData.add();
            System.out.println(Thread.currentThread().getName()+"\t update number = " + myData.number);
        },"t1").start();

        while (myData.number == 0) {

        }
        System.out.println(Thread.currentThread().getName()+"\t 执行完,当前number = " +myData.number);
    }
}

运行结果见下图：

验证volatile不保证原子性

原子性指的是什么？

不可分割，完整性，也即某个线程正在做某个具体业务时，中间不可以被加塞或者被分割，需要整体完整要么同时成功，要么同时失败。

例子如下：

class MyData1 {
    volatile int number = 0;
    public void addPlus() {
        /** number++ 底层其实被拆分成了3个指令：
　　　　执行getfield拿到元原始number;
　　　　执行iadd进行加1操作；
　　　　执行putfield写把累加后的值写回
*/
        number++;
    }
    AtomicInteger atomicInteger = new AtomicInteger();
    public void addAtomic() {
        atomicInteger.getAndIncrement(); //CAS,底层是unsafe类和自旋，保证原子性
    }
}

/**
 * 验证volatile的原子性
 */
public class VolatileDemo1 {
    public static void main(String[] args) {
        MyData1 myData = new MyData1();
       for(int i = 1; i<=20; i++) {
           new Thread(() ->{
               for(int j = 1; j<= 1000; j++) {
                   myData.addPlus();
                   myData.addAtomic();
               }
           },String.valueOf(i)).start();
       }
        //需要等待上面20个线程都全部计算完成后，再用main线程取得最终的结果看是多少
        while (Thread.activeCount() > 2) {
           Thread.yield();
        }

        System.out.println(Thread.currentThread().getName()+"\t int number 的最终结果是" +myData.number);
        System.out.println(Thread.currentThread().getName()+"\t atomic number 的最终结果是" +myData.atomicInteger);
    }
}

运行结果见下图：

原因分析：例如有3个线程同时写操作，主内存值是0，3个线程分别拷贝自己工作内存后值0都进行了加1，有可能线程1刚把值1写入了主内存，线程2或线程3由于某些原因挂起现在突然被唤醒，由于时间太快还没收到最新值的通知又去写成1，等于写覆盖丢失了数据，正常主内存的值是3，结果3个线程操作写覆盖结果变成1。可以使用JUC下面的AtomicInteger解决原子性i++问题。

volatile指令重排

计算机再执行程序时，为了提高性能，编译器和处理器的常常会对指令做重排，一般分为以下3种

源代码→编译器优化的重排→指令并行的重排→内存系统的重排→最终执行的指令

单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致。

处理器在进行重排序时必须要考虑指令之间的数据依赖性。

多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。

例子：

public class ReSortDemo {
    int a = 0;
    boolean flag = false;
    public void method1() {
        a = 1;
        flag = true;
    }

    /**
     * 多线程环境中线程交替执行，由于编译器优化重排的存在
     * 两个线程中使用的变量能否保证一致性无法确定， 变量a 和变量 flag 由于不存在依赖性，多线程下指令重排可能先执行flag,
     * 而变量a 还是旧值0，打印结果就可能是5而不是6
     */
    public void method2() {
        if(flag) {
            a = a+5;
            System.out.println(a);
        }
    }
}

单例模式volatile例子：

public class SingletonDemo {
    private  static volatile SingletonDemo instance = null;
    private SingletonDemo() {
        System.out.println(Thread.currentThread().getName()+"我是构造方法");
    }

    /** DCL(双层检锁机制)不一定线程安全，原因是有指令重排序的存在，加入volatile可以禁止指令重排
     * 原因在于某一个线程执行到第一个检测，读取到的instance不为null时，instance的引用对象可能没有完成初始化
     * instance = new SingletonDemo();可以分为以下3步完成（伪代码）
     * memory = allocate();//1. 分配对象内存空间
     * instance(memory);//2.初始化对象
     * instance = memory;//3.设置instance指向刚分配的内存地址，此时instance != null
     *步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后程序的执行结果在单线程中并没有改变，因此这种重排序
     * 是允许的
     * 多线程下可能导致的顺序就是132
     * @return
     */
    public static SingletonDemo getInstance() {
        if(instance == null) {
            synchronized (SingletonDemo.class) {
                if(instance == null) {
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        //模拟10个线程
        for (int i = 1; i<= 10; i++) {
            new Thread(() ->{
                SingletonDemo.getInstance();
            },String.valueOf(i)).start();
        }
    }
}

运行结果如下：

volatile用法

标签：问题   ret   现在   不为   一个   try   OLE   例子   导致   

原文地址：https://www.cnblogs.com/liuyi13535496566/p/12147759.html