JUC多线程与高并发面试题——volatile

一、volatile是什么？

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

二、volatile的三个特性？

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

三、JMM与volatile

3.1 JMM介绍

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

    JMM关于同步的规定：

• 线程解锁前，必须把共享变量的值刷新回主内存。
• 线程加锁前，必须读取主内存的最新值到自己的工作内存。
• 加锁解锁是同一把锁。

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

3.2 volatile保证可见性代码验证

3.2.1 不可见代码：

package com.yuxx.juc;
 
import java.util.concurrent.TimeUnit;
 
public class VolatileDemo {
    public static void main(String[] args) {
        MyData myData = new MyData();
        new Thread(()->{
            System.out.println(Thread.currentThread().getName() + " come in");
            try{ TimeUnit.SECONDS.sleep(3); }catch (InterruptedException e){ e.printStackTrace(); }
            myData.addTo60();
            System.out.println(Thread.currentThread().getName() + " updated number value:"+myData.number);
        },"AAA").start();
        while(myData.number == 0){
            //main线程一直在这里等待循环，直到number值不再等于0
        }
        System.out.println(Thread.currentThread().getName() + " mission is over");
    }
}
class MyData{
    int number = 0;//注意，此处没有任何其他修饰
    public void addTo60(){
        this.number = 60;
    }
}

打印结果：

最后的“mission is over”没有打印，且程序没有结束，是因为线程AAA将number的值修改后，main线程并不知道number值已修改，还是原来的值0，导致main线程的while循环一直在等待。

3.2.2 volatile保证可见性代码

package com.yuxx.juc;
 
import java.util.concurrent.TimeUnit;
 
public class VolatileDemo {
    public static void main(String[] args) {
        MyData myData = new MyData();
        new Thread(()->{
            System.out.println(Thread.currentThread().getName() + " come in");
            try{ TimeUnit.SECONDS.sleep(3); }catch (InterruptedException e){ e.printStackTrace(); }
            myData.addTo60();
            System.out.println(Thread.currentThread().getName() + " updated number value:"+myData.number);
        },"AAA").start();
        while(myData.number == 0){
            //main线程一直在这里等待循环，直到number值不再等于0
        }
        System.out.println(Thread.currentThread().getName() + " mission is over");
    }
}
class MyData{
    volatile int number = 0;//此行有volatile修饰
    public void addTo60(){
        this.number = 60;
    }
}

打印结果：

3.3 volatile不保证原子性代码验证

3.3.1 不保证原子性代码

package com.yuxx.juc;
 
class MyData{
    volatile int number = 0;
    public void addPlusPlus(){
        number++;
    }
}
/**
 * 2 验证volatile 不保证原子性
 *  2.1 原子性指的是什么意思？
 *      不可分割，完整性，也即某个线程正在做某个具体业务时，中间不可以被加塞或者被分割，需要整体完整。要么同时成功，要么同时失败。
 *  2.2 volatile不保证原子性的案例演示
 *  2.3 why？
 */
public class VolatileDemo {
 
    public static void main(String[] args) {
        MyData myData = new MyData();
        for(int i=0;i<20;i++){
            new Thread(()->{
                for(int j = 1;j<=1000;j++){
                    myData.addPlusPlus();
                }
            },String.valueOf(i)).start();
        }
        while(Thread.activeCount() > 2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + " finally number value : " + myData.number);
    }
}

打印结果：

原因：

     i++操作在字节码文件中是分为三步：
     _temp = i;
     i = i + 1;
     i = _temp;
     可能出现的情况是，线程A和B同时拿到了执行权，A将i+1,B也将i+1,由于volatile不保证原子性，在A将i的值写回主存前的一瞬间，B已经将i+1后的值写回主存，此时A再将i+1的值返回主内存，就会覆盖掉之前B写回的内容，造成数据丢失。

3.3.2 解决volatile不保证原子性的办法

package com.yuxx.juc;
 
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
 
class MyData{
    //atomicInteger默认值为0
    AtomicInteger atomicInteger = new AtomicInteger();
    public void addMyAtomic(){
        atomicInteger.getAndIncrement();
    }
}
/**
 * 2 验证volatile 不保证原子性
 *  2.1 原子性指的是什么意思？
 *      不可分割，完整性，也即某个线程正在做某个具体业务时，中间不可以被加塞或者被分割，需要整体完整。要么同时成功，要么同时失败。
 *  2.2 volatile不保证原子性的案例演示
 *  2.3 why？
 *  2.4 如何解决
 *      * 加synchronized
 *      * 使用JUC下的AtomicInteger（底层是CAS算法）
 */
public class VolatileDemo {
 
    public static void main(String[] args) {
        MyData myData = new MyData();
        for(int i=0;i<20;i++){
            new Thread(()->{
                for(int j = 1;j<=1000;j++){
                    myData.addMyAtomic();
                }
            },String.valueOf(i)).start();
        }
        while(Thread.activeCount() > 2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + " AtomicInteger type,finally number value : " + myData.atomicInteger);
    }
}

解决办法说明：将int类型，改为juc下的AtomicInteger，int i++ 改为 AtomicInteger.getAndIncrement(实例方法)，AtomicXxx，底层实现是CAS算法。

3.4 volatile与指令重排

3.4.1 指令重排

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

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

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

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

3.4.2 指令重排演示

DEMO-1：

DEMO-2：

3.4.3 指令重排案例

public class ReSortSeqDemo {
    int a = 0;
    boolean flag = false;

    public void method01(){
        a = 1;//语句1
        flag = true;//语句2
    }

    //多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测
    public void method02(){
        if(flag){
            a = a + 5;//语句3
            System.out.println("retValue：" + a);
        }
    }
}

说明：

    一般正常情况下，执行顺序是：语句1-语句2-语句3，最后执行结果是6。
    但是由于编译器指令重排的客观存在，在多线程情况下，会导致这种情况：线程A在method01中，语句1和语句2顺序反过来了，先执行语句2，把flag变为true，还没有执行语句1，线程B进入method02方法，此时flag为true，a为0，a+5赋值给a，打印出来的a是5。
    这就导致了指令重排后，造成数据的不一致。

3.4.4 volatile禁止指令重排

3.4.4.1 内存屏障

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

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

    由于编译器和处理器都能执行指令重排优化，如果在指令间插入一条Memory Barrier，则会告诉编译器和CPU，不管什么指令都不能和这条Memory Barrier 指令重排序。也就是说，通过内存屏障禁止在内存屏障前后的指令执行重排优化。

    内存屏障的另一个作用是强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读到这些数据的最新版本。

    对volatile变量进行写操作时，会在写操作后加入一条store屏障指令，将工作内存中的共享变量值刷回主内存。

    

    对volatile变量进行读操作时，会在读操作前加入一条load屏障指令，从主内存中读取共享变量。

3.5 volatile的使用

3.5.1 单例模式DCL及在多线程下的问题

package com.yuxx.juc;

public class SingletonDemo {

    private static SingletonDemo instance = null;

    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName() + "\t 我是构造方法SingletonDemo()");
    }

    //DCL（Double Check Lock 双端检锁机制）
    public static SingletonDemo getInstance() {
        if(instance == null){
            synchronized (SingletonDemo.class){
                if(instance == null){
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }

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

    DCL（双端检锁）机制并不一定安全，原因是指令重排序的存在。

    原因在于，在某个线程执行到第一次检测，读取到的instance不为null时，instance的引用对象可能已经开始初始化但是还没有初始化完成。

instance = new SingletonDemo();可以分为以下3步完成（伪代码）：     >memory = allocate();//1.分配内存空间     >instance(memory);//2.初始化对象     >instance = memory;//3.设置instance指向刚分配的内存地址，此时instance != null     步骤2和步骤3不存在数据依赖关系，而且无论重排前还是重排后，程序的执行结果在单线程中并没有改变，所以重排时允许的。     >memory = allocate();//1.分配对象内存空间     >instance = memory;//3.设置instance指向刚分配的内存地址，此时instance != null，但是对象还没有初始化完成     >instance(memory);//2.初始化对象

    但是指令重排只会保证串行语义的执行的一致性（单线程），并不会关注多线程间的语义一致性。

    所以当一条线程访问instance 不为 null 时，由于instance 实例未必初始化完成，也就造成了线程安全问题。

3.5.2 volatile解决单例模式DCL多线程不安全问题

package com.yuxx.juc;

public class SingletonDemo {

    private static volatile SingletonDemo instance = null;

    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName() + "\t 我是构造方法SingletonDemo()");
    }

    //DCL（Double Check Lock 双端检锁机制）
    public static SingletonDemo getInstance() {
        if(instance == null){
            synchronized (SingletonDemo.class){
                if(instance == null){
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }

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

 

转载于:https://my.oschina.net/alexjava/blog/3100848