volatile关键字

　　博主的第一篇博客，一直想开始写自己的博客，但是犹豫各种原因（主要是懒），一直没有开始。好了，废话不多说，进入正题。

　　关于volatile这个关键字，以前一直有听说，也在不经意间见到过，但从没去深究。一直模糊得认为和synchronized关键字类似，在多线程编程时候有保证线程安全的功能。关于synchronized关键字以后再说，本篇文章就来聊聊volatile。

　　在了解volatile之前，必须要了解并发编程中的三个概念和内存模型相关的知识（没办法，不了解这些就没法透彻了解volatile关键字）。

　　一.内存模型

　　计算机在执行程序时，每条指令都是在CPU中执行的，而执行指令过程中，势必涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存（物理内存）当中的，这时就存在一个问题，由于CPU执行速度很快，而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢的多，因此如果任何时候对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度。因此在CPU里面就有了高速缓存。

　　也就是，当程序在运行过程中，会将运算需要的数据从主存复制一份到CPU的高速缓存当中，那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据，当运算结束之后，再将高速缓存中的数据刷新到主存当中。举个简单的例子，比如下面的这段代码

　　i=i+1;

 　　当线程执行这个语句时，会先从主存当中读取i的值，然后复制一份到高速缓存当中，然后CPU执行指令对i进行加1操作，然后将数据写入高速缓存，最后将高速缓存中i最新的值刷新到主存当中。比如同时有2个线程执行这段代码，假如初始时i的值为0，那么我们希望两个线程执行完之后i的值变为2。但是事实会是这样吗？可能存在下面一种情况：初始时，两个线程分别读取i的值存入各自所在的CPU的高速缓存当中，然后线程1进行加1操作，然后把i的最新值1写入到内存。此时线程2的高速缓存当中i的值还是0，进行加1操作之后，i的值为1，然后线程2把i的值写入内存。

　　二.并发编程中的三个概念

　　并发编程中的三个概念：1.原子性，2.可见性，3.有序性

　　1.原子性：即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

　　2.可见性： 可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。（volatile关键字就保证了可见性）

  1. 　　//线程1执行的代码
  2. 　　int i = 0;
  3. 　　i = 10;
  5. 　　//线程2执行的代码
  6. 　　j = i;

　　假若执行线程1的是CPU1，执行线程2的是CPU2。由上面的分析可知，当线程1执行 i =10这句时，会先把i的初始值加载到CPU1的高速缓存中，然后赋值为10，那么在CPU1的高速缓存当中i的值变为10了，却没有立即写入到主存当中。此时线程2执行 j = i，它会先去主存读取i的值并加载到CPU2的缓存当中，注意此时内存当中i的值还是0，那么就会使得j的值为0，而不是10.这就是可见性问题，线程1对变量i修改了之后，线程2没有立即看到线程1修改的值。

　　3.有序性：即程序执行的顺序按照代码的先后顺序执行。（volatile关键字也保证了有序性）举个简单的例子，看下面这段代码：　　

  1. 　　//线程1:
  2. 　　context = loadContext();   //语句1
  3. 　　inited = true;             //语句2
  4. 　　//线程2:
  5. 　　while(!inited ){
  6.   　　sleep()
  7. 　　}
  8. 　　doSomethingwithconfig(context);

　　由于语句1和语句2没有数据依赖性，因此可能会被重排序。假如发生了重排序，在线程1执行过程中先执行语句2，而此是线程2会以为初始化工作已经完成，那么就会跳出while循环，去执行doSomethingwithconfig(context)方法，而此时context并没有被初始化，就会导致程序出错。如果在inited前加上volatile（volatile inited = true;）,那么语句1一定在语句2之前执行。volatile修饰一个关键字，那么这段语句前面的代码执行完才会执行这段代码，而这段代码后面的语句也会在本段代码执行结束才会执行。

　　三.volatile关键字

　　在前面讲述了很多东西，其实都是为讲述volatile关键字作铺垫，那么接下来我们就进入主题。

1.volatile关键字的两层语义

　　一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

　　1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

　　2）禁止进行指令重排序。

　　先看一段代码，假如线程1先执行，线程2后执行：

  1. 　　//线程1
  2. 　　booleanstop = false;
  3. 　　while(!stop){
  4.     doSomething();
  5. 　　}
  6. 　　//线程2
  7. 　　stop = true;

 　　这段代码是很典型的一段代码，很多人在中断线程时可能都会采用这种标记办法。但是事实上，这段代码会完全运行正确么？即一定会将线程中断么？不一定，也许在大多数时候，这个代码能够把线程中断，但是也有可能会导致无法中断线程（虽然这个可能性很小，但是只要一旦发生这种情况就会造成死循环了）。

　　下面解释一下这段代码为何有可能导致无法中断线程。在前面已经解释过，每个线程在运行过程中都有自己的工作内存，那么线程1在运行的时候，会将stop变量的值拷贝一份放在自己的工作内存当中。

　　那么当线程2更改了stop变量的值之后，但是还没来得及写入主存当中，线程2转去做其他事情了，那么线程1由于不知道线程2对stop变量的更改，因此还会一直循环下去。

　　但是用volatile修饰之后就变得不一样了：

　　第一：使用volatile关键字会强制将修改的值立即写入主存；

　　第二：使用volatile关键字的话，当线程2进行修改时，会导致线程1的工作内存中缓存变量stop的缓存行无效（反映到硬件层的话，就是CPU的L1或者L2缓存中对应的缓存行无效）；

　　第三：由于线程1的工作内存中缓存变量stop的缓存行无效，所以线程1再次读取变量stop的值时会去主存读取。

　　那么在线程2修改stop值时（当然这里包括2个操作，修改线程2工作内存中的值，然后将修改后的值写入内存），会使得线程1的工作内存中缓存变量stop的缓存行无效，然后线程1读取时，发现自己的缓存行无效，它会等待缓存行对应的主存地址被更新之后，然后去对应的主存读取最新的值。

　　那么线程1读取到的就是最新的正确的值。

2.volatile保证原子性吗？

　　从上面知道volatile关键字保证了操作的可见性，但是volatile能保证对变量的操作是原子性吗？

　　下面看一个例子：

  1. 　　public class Test {
  2.     　　public volatile int inc = 0;
  3.      
  4.     　　public void increase() {
  5.         　　inc++;
  6.     　　}
  7.      
  8.     　　public static void main(String[] args) {
  9.         　　final Test test = new Test();
  10.         　　for(int i=0;i<10;i++){
  11.             　　new Thread(){
  12.                 　　public void run() {
  13.                     　　for(int j=0;j<1000;j++)
  14.                         　　test.increase();
  15.                　　 };
  16.            　　 }.start();
  17.         　　}
  18.         
  19.        　　 while(Thread.activeCount()>1)  //保证前面的线程都执行完
  20.            　　 Thread.yield();
  21.         　　System.out.println(test.inc);
  22.     　　}
  23. 　　}

 　　大家想一下这段程序的输出结果是多少？也许有些朋友认为是10000。但是事实上运行它会发现每次运行结果都不一致，都是一个小于10000的数字。

　　可能有的朋友就会有疑问，不对啊，上面是对变量inc进行自增操作，由于volatile保证了可见性，那么在每个线程中对inc自增完之后，在其他线程中都能看到修改后的值啊，所以有10个线程分别进行了1000次操作，那么最终inc的值应该是1000*10=10000。

　　这里面就有一个误区了，volatile关键字能保证可见性没有错，但是上面的程序错在没能保证原子性。可见性只能保证每次读取的是最新的值，但是volatile没办法保证对变量的操作的原子性。

　　在前面已经提到过，自增操作是不具备原子性的，它包括读取变量的原始值、进行加1操作、写入工作内存。那么就是说自增操作的三个子操作可能会分割开执行，就有可能导致下面这种情况出现：

　　假如某个时刻变量inc的值为10，

　　线程1对变量进行自增操作，线程1先读取了变量inc的原始值，然后线程1被阻塞了；

　　然后线程2对变量进行自增操作，线程2也去读取变量inc的原始值，由于线程1只是对变量inc进行读取操作，而没有对变量进行修改操作，所以不会导致线程2的工作内存中缓存变量inc的缓存行无效，所以线程2会直接去主存读取inc的值，发现inc的值时10，然后进行加1操作，并把11写入工作内存，最后写入主存。 

　　然后线程1接着进行加1操作，由于已经读取了inc的值，注意此时在线程1的工作内存中inc的值仍然为10，所以线程1对inc进行加1操作后inc的值为11，然后将11写入工作内存，最后写入主存。

　　那么两个线程分别进行了一次自增操作后，inc只增加了1。

　　解释到这里，可能有朋友会有疑问，不对啊，前面不是保证一个变量在修改volatile变量时，会让缓存行无效吗？然后其他线程去读就会读到新的值，对，这个没错。这个就是上面的happens-before规则中的volatile变量规则，但是要注意，线程1对变量进行读取操作之后，被阻塞了的话，并没有对inc值进行修改。然后虽然volatile能保证线程2对变量inc的值读取是从内存中读取的，但是线程1没有进行修改，所以线程2根本就不会看到修改的值。

　　根源就在这里，自增操作不是原子性操作，而且volatile也无法保证对变量的任何操作都是原子性的。

　　把上面的代码改成以下任何一种都可以达到效果：

  1. package com.study;
  3. import java.util.concurrent.atomic.AtomicInteger;
  4. import java.util.concurrent.locks.Lock;
  5. import java.util.concurrent.locks.ReentrantLock;
  7. public class Test {
  9. // public volatile int inc = 0;
  11. //不加锁，线程不安全
  12. // public void increase() {
  13. // inc++;
  14. // System.out.println("inc======="+inc);
  15. // }
  17. //加锁1，线程安全 synchronized
  18. // public synchronized void increase() {
  19. // inc++;
  20. // System.out.println("inc======="+inc);
  21. // }
  23. //加锁2，线程安全 Lock
  24. // Lock lock = new ReentrantLock();
  25. // public void increase() {
  26. // lock.lock();
  27. // try {
  28. // inc++;
  29. // } finally{
  30. // lock.unlock();
  31. // }
  32. // }
  34. //加锁3，线程安全 AtomicInteger
  35. public AtomicInteger inc = new AtomicInteger();
  36. public void increase() {
  37. inc.getAndIncrement();
  38. }
  40. public static void main(String[] args) {
  41. final Test test = new Test();
  42. for(int i=0;i<100;i++){
  43. new Thread(){
  44. public void run() {
  45. for(int j=0;j<1000;j++)
  46. test.increase();
  47. };
  48. }.start();
  49. }
  51. while(Thread.activeCount()>1) //保证前面的线程都执行完
  52. Thread.yield();
  53. System.out.println(test.inc);
  54. }
  56. }

 

　　结论： volatile关键字不能保证多线程并发编程中一定是线程安全的，但是能保证可见性和有序性。当我们使用类似下面用flag标记状态量的时候，最好使用volatile

volatile boolean flag = false;

while(!flag){
    doSomething();
}
如果要保证线程安全，还要结合synchronized或者Lock使用

 

参考资料：http://www.cnblogs.com/dolphin0520/p/3920373.html

 

posted @ 2017-11-09 23:17  想成为架构师的码农  阅读(91)  评论(0)    收藏  举报