JUC--volatile

JUC–volatile

JUC===Package java.util.concurrent，实用程序类通常在并发编程中很有用，从今天开始分享一些相关知识，首先就是volatile。

volatile

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

保证可见性,不保证原子性

class MyDataA{//volatile 不保证原子性 MyDataA.java===> MyDataA.class===>JVM字节码
    volatile int number = 0;
    public void addTo60(){
        this.number=60;
    }
    //volatile 不保证原子性
    //synchronized 自然可以 但是杀鸡焉用牛刀 太重了
    public void addPlusPlus(){
        number++;
    }
}
/**
     * 2. 验证volatile不保证原子性
     *  2.1原子性是什么？
     *      不可分割、完整性，也即某个线程正在做某个具体业务时，中间不可以被加塞或者被分割，需要整体完整
     *      要么同时成功，要么同时失败
     *  2.2 volatile不保证原子性的案例演示
     *  2.3 why?
     */
    @Test
    public void test3(){
        MyDataA myDataA= new MyDataA();
        for(int i=0;i<20;i++){
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    myDataA.addPlusPlus();
                }
            },String.valueOf(i)).start();
        }
        //等待20线程完成后，取得最终结果值看是多少
        //基础线程+main线程，大于两个代表还有内部线程未完成，yield 礼让线程
        while(Thread.activeCount()>2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"t finally number value :"+myDataA.number );
    }

JVM字节码解析：

如何解决原子性：

java.util.concurrent.atomic.AtomicInteger

class MyDataA{//volatile 不保证原子性 MyDataA.java===> MyDataA.class===>JVM字节码
    volatile int number = 0;
    //volatile 不保证原子性
    //synchronized 自然可以 但是杀鸡焉用牛刀 太重了
    public void addPlusPlus(){
        number++;
    }
    //解决原子性问题
    AtomicInteger atomicInteger = new AtomicInteger();
    public void addMyAtomic(){
        atomicInteger.getAndIncrement();
    }
}

/**
     * 2. 验证volatile不保证原子性
     *  2.1原子性是什么？
     *      不可分割、完整性，也即某个线程正在做某个具体业务时，中间不可以被加塞或者被分割，需要整体完整
     *      要么同时成功，要么同时失败
     *  2.2 volatile不保证原子性的案例演示
     *  2.3 why?
     *  2.4如何解决原子性？
     *      * 加synchronized 可以 但是不要杀鸡用牛刀
     *      * 使用我们的juc下的AtomicInteger
     */
    @Test
    public void test3(){
        MyDataA myDataA= new MyDataA();
        for(int i=0;i<20;i++){
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    myDataA.addPlusPlus();
                    myDataA.addMyAtomic();
                }
            },String.valueOf(i)).start();
        }
        //等待20线程完成后，取得最终结果值看是多少
        //基础线程+main线程，大于两个代表还有内部线程未完成，yield 礼让线程
        while(Thread.activeCount()>2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"t int finally number value :"+myDataA.number );
        System.out.println(Thread.currentThread().getName()+"t AtomicInteger finally number value :"+myDataA.atomicInteger );
    }

禁止指令重排(了解)

总结：volatile实现了禁止指令重排优化，从而避免多线程环境下程序出现乱序执行的现象。

内存屏障（Memory Barrier）又称内存栅栏，是一个CPU指令，它的作用如下：

（1）保证特定操作的执行顺序。

（2）保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）

由于编译器和处理器都能执行指令重排优化，如果在指令间插入一条Memory Barrier 则会告诉编译器和CPU，不管什么指令都不能和这条Memory Barrier 指令重排序，也就是说通过插入内存屏障禁止在内存屏障前后的指令执行重排序优化。内存屏障另外一个作用是强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据的最新版本。