深入了解轻量级的同步机制volatile

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

• 保证可见性
• 禁止指令排序
• 不保证原子性

 

一、验证volatile的可见性

         1.1 假如number = 0，number变量之前根本没有添加volatile关键字，没有可见性

         1.2 添加volatile，可解决可见性的问题

package com.jmm.volatiles;

import java.util.concurrent.TimeUnit;

/**
 * @description: volatile可见性
 * @author: Mr.Li
 * @create: 2019-09-10 16:42
 *
 *   1. 验证volatile的可见性
 *   1.1 假如number = 0，number变量之前根本没有添加volatile关键字，没有可见性
 *   1.2 添加volatile，可解决可见性的问题
 *
 **/

class Date {
    //int number = 0;
    volatile int number = 0;

    //验证可见性
    public void add() {
        this.number = 20;
    }
}
public class VolatileDemo1 {
    public static void main(String[] args) {
        seeOkVolatile();
    }

    private static void seeOkVolatile() {
        Date date = new Date();
        System.out.println(Thread.currentThread().getName() + " coming...");
        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(3);         //暂停3秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            date.add();
            System.out.println(Thread.currentThread().getName() + "update number" + date.number);
        },"test1").start();

        while (date.number == 0) {

        }

        System.out.println(Thread.currentThread().getName() + "mission is over");
    }
}

运行结果：

不加volatile：程序一直未停止，死循环

加上volatile：循环结束，输出循环后的语句

如果不加 volatile 关键字，则主线程会进入死循环，加 volatile 则主线程能够退出，说明加了 volatile 关键字变量，当有一个线程修改了值，会马上被另一个线程感知到，当前值作废，从新从主内存中获取值。对其他线程可见，这就叫可见性。

 

二、验证volatile不保证原子性

*   2. 验证volatile不保证原子性
*   2.1 原子性是指？
*          不可分割，完整性。也就是某个线程保证具体业务时，中间不可以被加塞或分割，需要整体完整,
*       要么同时成功，要么同时失败
*
*   2.2 如何解决原子性
*      2.2.1、加synchronized
*      2.2.2、使用juc下的AtomicInteger

package com.jmm.volatiles;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @description: volatile可见性
 * @author: Mr.Li
 * @create: 2019-09-10 16:42
 *
 *   2. 验证volatile不保证原子性
 *   2.1 原子性是指？
 *          不可分割，完整性。也就是某个线程保证具体业务时，中间不可以被加塞或分割，需要整体完整
 *          要么同时成功，要么同时失败
 *
 *   2.2 如何解决原子性
 *      2.2.1、加synchronized
 *      2.2.2、使用juc下的AtomicInteger
 **/
class Date {
    volatile int number = 0;

    //验证不保证原子性
    public void addPlus1() {
        this.number++;
    }

    //验证保证原子性方法1
    public synchronized void addPlus2() {
        this.number++;
    }

    //验证保证原子性方法2
    AtomicInteger atomicInteger = new AtomicInteger();
    public void addAtomic() {
        atomicInteger.getAndIncrement();
    }
}
public class VolatileDemo1 {
    public static void main(String[] args) {
        Date date = new Date();
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 1; j <= 1000; j++) {
                    date.addPlus1();    //不保证原子性
                    //date.addPlus2();    //保证原子性
                    date.addAtomic();    //保证原子性
                }
            },String.valueOf(i)).start();

        }
        // 默认有 main 线程和 gc 线程
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        //输出值
        System.out.println(Thread.currentThread().getName() + '\t' + date.number);
        System.out.println(Thread.currentThread().getName() + '\t' + date.atomicInteger);
    }

   
}

运行结果：

         可见，volatile并不能保证原子性。而加synchronized、或使用juc下的AtomicInteger能保证原子性，推荐使用AtomicInteger，因为synchronized并不能保证有很好的效率。

 

三、禁止指令排序

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

• 编译器优化的重排
• 内存系统的重排
• 指令并行的重排
  •  单线程环境里面确保程序最终执行的结果和代码执行的结果一致
  • 处理器在进行重排序时必须考虑指令之间的数据依赖性
  • 多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证用的变量能否一致性是无法确定的，结果无法预测，所以引申出了禁止指令排序

禁止指令排序

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

先了解一个概念，内存屏障（Memory Barrier）又称内存栅栏，是一个 CPU 指令，他的作用有两个：

• 保证特定操作的执行顺序
• 保证某些变量的内存可见性（利用该特性实现 volatile 的内存可见性）

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

 

每日一言：

青春的代价就是什么都想要，什么都想试试看