volatile关键字浅析

Java并发之volatile关键字：

       在32位系统中，long和double是采用了高低位两个位置进行操作的。在操作系统级别就需要两个动作才能完成，所以不是原子性的。

       对单个的变量操作是原子性的。但是在多个线程进行累加的操作，这个累加的操作并不是原子性的啊。那么多次累加，人家没保证原子性。这里是两个东西，不能混为一谈。

 

    内存模型：执行程序时，计算机先从内存读取数据到cpu高速缓存，线程在读取高速缓存里的数据进行运算。

    

    例如：i=i+1；

    实际情况：多线程执行时，可能线程会在不同cpu中执行。例如执行两个线程的i+1，i初始值为0；当两个线程执行完之后，应当结果为i=2。但如果线程在两个不同的cpu中执行，两个cpu都同时读取了内存中的数据。此时初识值都为i=0，那结果将是i=1。

        

    解决方案（硬件层面）：

        1、通过在总线加LOCK#锁的方式。

        2、通过缓存一致性协议。当数据a更改后，会将其他线程数据a副本失效，其他线程要重新获取数据a。

        

        LOCK#缺点：锁会导致内存访问受阻，导致相率低下。

 

    并发编程的三个概念：

    

    1、原子性：一个操作或多个操作，必须全部完成并且过程中不能被任何因素打断，或者都不执行。synchronized和Lock锁住执行代码块，可以保证原子性。

 

    2、可见性：多个线程访问同一个数据，保证其他线程能实时看见这个数据的最新状态。保证对共享资源操作实时有效。使用volatile修饰变量，线程修改变量值时会实时更新到内存中。保证可见性。

 

    3、有序性：程序按照代码顺序执行。

                

        在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。

　　在Java里面，可以通过volatile关键字来保证一定的“有序性”（具体原理在下一节讲述）。另外可以通过synchronized和Lock来保证有序性，很显然，synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性。

　　另外，Java内存模型具备一些先天的“有序性”，即不需要通过任何手段就能够得到保证的有序性，这个通常也称为 happens-before 原则。如果两个操作的执行次序无法从happens-before原则推导出来，那么它们就不能保证它们的有序性，虚拟机可以随意地对它们进行重排序。

            下面就来具体介绍下happens-before原则（先行发生原则）：

• 程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作

• 锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作

• volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作

• 传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C

• 线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作

• 线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生

• 线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行

• 对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始

 

volatile关键字的两层含义：

    1、保证不同线程对这个变量进行操作时的立即可见性。

    

    

    但是，volatile能保证变量的可见性，但不能保证对变量操作的原子性。

 

    例：下面代码实际执行结果，inc总会小于1000。因为对inc++的操作不是原子性。

public class Test {

    public volatile int num = 0;

     

    public void add() {

        num++;

    }

     

    public static void main(String[] args) {

        final Test test = new Test();

        for(int i=0;i<10;i++){

            new Thread(){

                public void run() {

                    for(int j=0;j<1000;j++)

                        test.add();

                };

            }.start();

        }        

        while(Thread.activeCount()>1)  //保证前面的线程都执行完

            Thread.yield();

        System.out.println(test.num);

    }

}

保证原子性的三种方式：

采用synchronized：

public class Test {

    public  int  num = 0;

    

    public synchronized void add() {

        num++;

    }

    

    public static void main(String[] args) {

        final Test test = new Test();

        for(int i=0;i<10;i++){

            new Thread(){

                public void run() {

                    for(int j=0;j<1000;j++)

                        test.add();

                };

            }.start();

        }

        

        while(Thread.activeCount()>1)  //保证前面的线程都执行完

            Thread.yield();

        System.out.println(test.num);

    }

}

　　采用Lock：

public class Test {

    public  int num= 0;

    Lock rtLock = new ReentrantLock();

    

    public  void add() {

        rtLock .lock();

        try {

            num++;

        } finally{

            rtLock .unlock();

        }

    }

    

    public static void main(String[] args) {

        final Test test = new Test();

        for(int i=0;i<10;i++){

            new Thread(){

                public void run() {

                    for(int j=0;j<1000;j++)

                        test.add();

                };

            }.start();

        }

        

        while(Thread.activeCount()>1)  //保证前面的线程都执行完

            Thread.yield();

        System.out.println(test.num);

    }

}

　　采用AtomicInteger：是java.util.concurrent.atomic包下的一个原子操作类。执行自增1。

 

public class Test {

    public  AtomicInteger num= new AtomicInteger();

     

    public  void add() {

        num.getAndIncrement();

    }

    

    public static void main(String[] args) {

        final Test test = new Test();

        for(int i=0;i<10;i++){

            new Thread(){

                public void run() {

                    for(int j=0;j<1000;j++)

                        test.add();

                };

            }.start();

        }

        

        while(Thread.activeCount()>1)  //保证前面的线程都执行完

            Thread.yield();

        System.out.println(test.num);

    }

}

2、禁止进行执行重排序：

          1）当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；

　　    2）在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。

      例：当inited没有被volatile修饰时，语句1和语句2可能以不同顺序执行。可能会导致线程2执行时，inited状态已改变，但是context还没初始化，导致代码出错。

            当inited被volatile修饰时，就可以避免这种情况。因为当执行到改变inited时，必须保证context的执行。

//线程1：

context = loadContext();   //语句1

inited = true;             //语句2

//线程2:

while(!inited ){

  sleep()

}

doSomethingwithconfig(context);

    

    “观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令”

　　lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：

　　1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；

　　2）它会强制将对缓存的修改操作立即写入主存；

　　3）如果是写操作，它会导致其他CPU中对应的缓存行无效。

    使用volatile的场景：

        synchronized关键字是防止多个线程同时执行一段代码，那么就会很影响程序执行效率，而volatile关键字在某些情况下性能要优于synchronized，但是要注意volatile关键字是无法替代synchronized关键字的，因为volatile关键字无法保证操作的原子性。通常来说，使用volatile必须具备以下2个条件：

　　1）对变量的写操作不依赖于当前值

　　2）该变量没有包含在具有其他变量的不变式中

        实际上，这些条件表明，可以被写入 volatile 变量的这些有效值独立于任何程序的状态，包括变量的当前状态。

　　    事实上，我的理解就是上面的2个条件需要保证操作是原子性操作，才能保证使用volatile关键字的程序在并发时能够正确执行。

    应用场景：

1.状态标记量

1 2 3 4 5 6 7 8 9

volatile boolean flag = false;   while(!flag){     doSomething(); }   public void setFlag() {     flag = true; }

1 2 3 4 5 6 7 8 9 10

volatile boolean inited = false; //线程1: context = loadContext();   inited = true;               //线程2: while(!inited ){ sleep() } doSomethingwithconfig(context);

2.double check

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

class Singleton{     private volatile static Singleton instance = null;           private Singleton() {               }           public static Singleton getInstance() {         if(instance==null) {             synchronized (Singleton.class) {                 if(instance==null)                     instance = new Singleton();             }         }         return instance;     } }