android 面试题 请谈谈对volatile的理解

volatile是使用在多线程环境下,单线程使用没啥作用,所以前提是多线程

volatile是java虚拟机提供的一种轻量级的Java同步机制,它有三大特性

1:保证可见性

2:不保证原子性

3:禁止指令重排

 

要完全的理解这个volatile要对jvm中的内存模型jmm(Java memory model)理解

我们的数据存储能力. 磁盘<内存<cpu(只计算)

Java内存模型规定所有变量都存储在主存（Main Memory）中（虚拟机内存的一部分）。每条线程还有自己的工作内存（Working Memory），线程的工作内存保存了被线程使用到的变量的主内存副本拷贝，线程对变量的所有操作（读取/赋值等）都必须在工作内存中进行，而不能直接读写主内存中的变量。不同线程之间也无法直接访问对方工作内存中的变量，线程间变量值的传递均需要通过主存来完成

从上面关于jmm的规定中解读出几个关键词

主内存   工作内存    副本拷贝 

我们以铁路系统买票作为例子讲解 比如G2134是从上海到九江的高铁,然后我们可以在杭州东买票到我家鄱阳站,别人还可以从上海到鄱阳,比如还剩下2张票 出现三个人来购票的情况

由于我mac没安装什么画图工具 就从网上截图了一张图:

这是二个线程访问主内存, 加入主内存又一个ticker(票)字段=2

那么A和B线程都会把这个ticker=2 拷贝到自己线程的工作内存,那么A和B线程中ticker=2,然后A线程修改了ticker变量的值取走了一张票,那么这个时候A线程的工作内存会刷新到主内存  这个时候主内存的ticker也等于1了,这个时候主内存会通知其他线程比如B线程把ticker的变量=1. 这就是volatile的第一个特性 保证了可见性,我们总结可见性的步骤

第一步:从主内存拷贝变量到各自的工作内存

第二步: 修改工作内存中拷贝过来的值

第三步:把工作内存改变的值刷新到主内存

第四步:主内存通过某种机制告诉其他线程(可以看作是观察者模式)

现在用代码来验证volatile的可见性

package thread;

public class VolatileTest {
    public static void main(String[] args) {
        Ticker ticker = new Ticker();
        new Thread(){
            @Override
            public void run() {
                System.out.println("线程进行休眠2秒");
                try {
                    sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程改变ticker变量的值为60");
                ticker.setTicker();

            }
        }.start();
        while(ticker.ticker==0){

        }
        System.out.println("变化后的值--->"+ticker.ticker);
    }

}
class Ticker{
     int ticker = 0;
    public void setTicker() {
        this.ticker = 60;
    }
}

运行后步会显示变化后的值。因为ticker一直都是等于0

现在把ticker变量用volatile进行修饰后main线程就能接受到上面的匿名线程改变后ticker的值

上面讲了volatile的第一个特性 volatile还有一个不保证原子性 ,那么什么是原子性呢？

原子性: 它不可分割 也就是某个线程在执行某个任务时候,中间不可以被分割,需要整体同时是成功整体同时是失败

public class VolatileTest {
    public static void main(String[] args) {
        Ticker ticker = new Ticker();
        for(int i=0;i<10;i++){
            new Thread(){
                @Override
                public void run() {
                    for(int j=0;j<=1000;j++){
                        ticker.setTicker();
                    }
                }
            }.start();
        }
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("变化后的值--->"+ticker.ticker);
    }

}
class Ticker{
     volatile int ticker = 0;
    public void setTicker() {
        ticker++;
    }
}

按照我们的计算ticker应该是10000,但是打印出来的是9749 是小于10000的

上面的代码就是验证volatile不具有原子性

为什么会出现这种情况呢?

首先看关键代码:

ticker++;

这个其实是分三步:

第一步:从主内存中读取ticker的值

第二步:在自己的工作内存对其++操作

第三步:把工作内存中的ticker修改后的值刷新到主内存中

 

比如有a b  c三个线程读取主内存中的ticker都是0 然后都对其++ 那么这个时候a. b. c中的ticker值都为1，然后刷新到主内存中,

a刷新到快到主内存时候线程挂起了,这个时候b线程把1刷新到了主内存后,然后a线程也把1刷新到主内存,就把b线程刷新到主内存的中1覆盖了,然后c线程拿到主内存中的1进行++后就变成了2,本来c线程中应该是3,这就是导致ticker值小于预期数的原因.

那么如何解决呢？

第一种解决方案是在setTicker()方法上添加synchronized进行同步

第二种解决方案是:

使用到并发线程中的一个类AtomicInteger

package thread;
import java.util.concurrent.atomic.AtomicInteger;

public class VolatileTest {
    public static void main(String[] args) {
        Ticker ticker = new Ticker();
        for(int i=0;i<10;i++){
            new Thread(){
                @Override
                public void run() {
                    for(int j=1;j<=1000;j++){
                        ticker.setTicker();
                    }
                }
            }.start();
        }
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("变化后的值--->"+ticker.atomicInteger);
    }


}
class Ticker{
    AtomicInteger atomicInteger = new AtomicInteger();
    public void setTicker() {
        atomicInteger.getAndIncrement();
    }
}

volatile还有一个特性:禁止指令重排