JAVA 多线程之volatile的介绍

时间  2019-11-12
标签 java 多线程 volatile 介绍 栏目 Java 繁體版
原文   原文链接

volatile的介绍

volatile的主要做用是：提示编译器该对象的值有可能在编译器未监测的状况下被改变。   java

volatile相似于你们所熟知的const也是一个类型修饰符。volatile是给编译器的指示来讲明对它所修饰的对象不该该执行优化。volatile的做用就是用来进行多线程编程。在单线程中那就是只能起到限制编译器优化的做用。因此单线程的童鞋们就不用浪费精力看下面的了。编程

 

volatile让变量每次在使用的时候，都从主存中取。而不是从各个线程的“工做内存”。安全

volatile具备synchronized关键字的“可见性”，可是没有synchronized关键字的“并发正确性”，也就是说不保证线程执行的有序性。多线程

也就是说，volatile变量对于每次使用，线程都能获得当前volatile变量的最新值。可是volatile变量并不保证并发的正确性。并发

=========================分割线1================================= 框架

在Java内存模型中，有main memory，每一个线程也有本身的memory (例如寄存器)。为了性能，一个线程会在本身的memory中保持要访问的变量的副本。这样就会出现同一个变量在某个瞬间，在一个线程的memory中的值可能与另一个线程memory中的值，或者main memory中的值不一致的状况。 

一个变量声明为volatile，就意味着这个变量是随时会被其余线程修改的，所以不能将它cache在线程memory中。ide

没有volatile的结果

      若是没有volatile，你将没法在多线程中并行使用到基本变量。下面举一个我开发项目的实例（这个实例采用的是C#语言但不妨碍咱们讨论C++）。在学校的一个.Net项目的开发中，我曾经在多线程监控中用到过一个基本变量Int32型的，我用它来控制多线程中监控的一个条件。考虑到基本变量是编译器自带的并且没法用lock锁上，我想固然的觉得是原子操做不会有多线程的问题，可实际运行后发现程序的运行有时正常有时异常，改成用Dictionary对象处理并加锁之后才完全正常。如今想来应该是多线程同时操做该变量了，具体的将在下面说清。函数

volatile的做用

      若是一个基本变量被volatile修饰，编译器将不会把它保存到寄存器中，而是每一次都去访问内存中实际保存该变量的位置上。这一点就避免了没有volatile修饰的变量在多线程的读写中所产生的因为编译器优化所致使的灾难性问题。因此多线程中必需要共享的基本变量必定要加上volatile修饰符。固然了，volatile还能让你在编译时期捕捉到非线程安全的代码。我在下面还会介绍一位大牛使用智能指针来顺序化共享区代码的方法，在此对其表示感谢。工具

      泛型编程中曾经说过编写异常安全的代码是很困难的，但是相比起多线程编程的困难来讲这就过小儿科了。多线程编程中你须要证实它正确，须要去反复地枯燥地调试并修复，固然了，资源竞争也是必须注意的，最可恨的是，有时候编译器也会给你点颜色看看。。。性能

class Student { public: void Wait() //在北航排队等吃饭实在是很痛苦的事情。。。 { while (!flag) { Sleep(1000); // sleeps for 1000 milliseconds } } void eat() { flag = true; } ... private: bool flag; };

      好吧，多线程中你就等着吃饭吧，可在这个地方估计你是永远等不到了，由于flag被编译器放到寄存器中去了，哪怕在你前面的那位童鞋告诉你flag=true了，可你就好像瞎了眼看不到这些了。这么诡异的状况的发生时由于你所用到的判断值是以前保存到寄存器中的，这样原来的地址上的flag值更改了你也没有获取。该怎么办呢？对了，改为volatile就解决了。

      volatile对基本类型和对用户自定义类型的使用与const有区别，好比你能够把基本类型的non-volatile赋值给volatile，但不能把用户自定义类型的non-volatile赋值给volatile，而const都是能够的。还有一个区别就是编译器自动合成的复制控制不适用于volatile对象，由于合成的复制控制成员接收const形参，而这些形参又是对类类型的const引用，可是不能将volatile对象传递给普通引用或const引用。

如何在多线程中使用好volatile

      在多线程中，咱们能够利用锁的机制来保护好资源临界区。在临界区的外面操做共享变量则须要volatile，在临界区的里面则non-volatile了。咱们须要一个工具类LockingPtr来保存mutex的采集和volatile的利用const_cast的转换（经过const_cast来进行volatile的转换）。

      首先咱们声明一个LockingPtr中要用到的Mutex类的框架：

class Mutex { public: void Acquire(); void Release(); ... };

      接着声明最重要的LockingPtr模板类：

template <typename T> class LockingPtr { public: // Constructors/destructors LockingPtr(volatile T& obj, Mutex& mtx) : pObj_(const_cast<T*>(&obj)), pMtx_(&mtx) { mtx.Lock(); } ~LockingPtr() { pMtx_->Unlock(); } // Pointer behavior T& operator*() { return *pObj_; } T* operator->() { return pObj_; } private: T* pObj_; Mutex* pMtx_; LockingPtr(const LockingPtr&); LockingPtr& operator=(const LockingPtr&); };

      尽管这个类看起来简单，可是它在编写争取的多线程程序中很是的有用。你能够经过对它的使用来使得对多线程中共享的对象的操做就好像对volatile修饰的基本变量同样简单并且从不会使用到const_cast。下面来给一个例子：

       假设有两个线程共享一个vector<char>对象：

class SyncBuf { public: void Thread1(); void Thread2(); private: typedef vector<char> BufT; volatile BufT buffer_; Mutex mtx_; // controls access to buffer_ };

      在函数Thread1中，你经过lockingPtr<BufT>来控制访问buffer_成员变量：

void SyncBuf::Thread1() { LockingPtr<BufT> lpBuf(buffer_, mtx_); BufT::iterator i = lpBuf->begin(); for (; i != lpBuf->end(); ++i) { ... use *i ... } }

      这个代码很容易编写和理解。只要你须要用到buffer_你必须建立一个lockingPtr<BufT>指针来指向它，而且一旦你这么作了，你就得到了容器vector的整个接口。并且你一旦犯错，编译器就会指出来：

void SyncBuf::Thread2() { // Error! Cannot access 'begin' for a volatile object BufT::iterator i = buffer_.begin(); // Error! Cannot access 'end' for a volatile object for (; i != lpBuf->end(); ++i) { ... use *i ... } }

      这样的话你就只有经过const_cast或LockingPtr来访问成员函数和变量了。这两个方法的不一样之处在于后者提供了顺序的方法来实现而前者是经过转换为volatile来实现。LockingPtr是至关好理解的，若是你须要调用一个函数，你就建立一个未命名的暂时的LockingPtr对象并直接使用：

unsigned int SyncBuf::Size() { return LockingPtr<BufT>(buffer_, mtx_)->size(); }

LockingPtr在基本类型中的使用

      在上面咱们分别介绍了使用volatile来保护对象的意外访问和使用LockingPtr来提供简单高效的多线程代码。如今来讨论比较常见的多线程处理共享基本类型的一种状况：

class Counter { public: ... void Increment() { ++ctr_; } void Decrement() { —-ctr_; } private: int ctr_; };

      这个时候可能你们都能看出来问题所在了。1.ctr_须要是volatile型。2.即使是++ctr_或--ctr_，这在处理中还是须要三个原子操做的（Read-Modify-Write）。基于上述两点，这个类在多线程中会有问题。如今咱们就来利用LockingPtr来解决：

class Counter { public: ... void Increment() { ++*LockingPtr<int>(ctr_, mtx_); } void Decrement() { —?*LockingPtr<int>(ctr_, mtx_); } private: volatile int ctr_; Mutex mtx_; };

 

volatile成员函数

      关于类的话，首先若是类是volatile则里面的成员都是volatile的。其次要将成员函数声明为volatile则同const同样在函数最后声明便可。当你设计一个类的时候，你声明的那些volatile成员函数是线程安全的，因此那些随时可能被调用的函数应该声明为volatile。考虑到volatile等于线程安全代码和非临界区；non-volatile等于单线程场景和在临界区之中。咱们能够利用这个作一个函数的volatile的重载来在线程安全和速度优先中作一个取舍。具体的实现此处就略去了。

 

在当前的Java内存模型下，线程能够把变量保存在本地内存（好比机器的寄存器）中，而不是直接在主存中进行读写。这就可能形成一个线程在主存中修改了一个变量的值，而另一个线程还继续使用它在寄存器中的变量值的拷贝，形成数据的不一致。 



要解决这个问题，只须要像在本程序中的这样，把该变量声明为volatile（不稳定的）便可，这就指示JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。通常说来，多任务环境下各任务间共享的标志都应该加volatile修饰。 


Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。并且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任什么时候刻，两个不一样的线程老是看到某个成员变量的同一个值。 

 

用volatile和不用volatile的区别，运行一下，就知道了。

不用volatile：

 
  1. package com.keyword;  
  2.   
  3. public class TestWithoutVolatile {  
  4.     private static boolean bChanged;  
  5.   
  6.     public static void main(String[] args) throws InterruptedException {  
  7.         new Thread() {  
  8.   
  9.             @Override  
  10.             public void run() {  
  11.                 for (;;) {  
  12.                     if (bChanged == !bChanged) {  
  13.                         System.out.println("!=");  
  14.                         System.exit(0);  
  15.                     }  
  16.                 }  
  17.             }  
  18.         }.start();  
  19.         Thread.sleep(1);  
  20.         new Thread() {  
  21.   
  22.             @Override  
  23.             public void run() {  
  24.                 for (;;) {  
  25.                     bChanged = !bChanged;  
  26.                 }  
  27.             }  
  28.         }.start();  
  29.     }  
  30.   
  31. }  


运行后，程序进入死循环了，一直在运行。

 

 

用volatile：

 package com.keyword;  

  1.   
  2. public class TestWithVolatile {  
  3.     private static volatile boolean bChanged;  
  4.   
  5.     public static void main(String[] args) throws InterruptedException {  
  6.         new Thread() {  
  7.   
  8.             @Override  
  9.             public void run() {  
  10.                 for (;;) {  
  11.                     if (bChanged == !bChanged) {  
  12.                         System.out.println("!=");  
  13.                         System.exit(0);  
  14.                     }  
  15.                 }  
  16.             }  
  17.         }.start();  
  18.         Thread.sleep(1);  
  19.         new Thread() {  
  20.   
  21.             @Override  
  22.             public void run() {  
  23.                 for (;;) {  
  24.                     bChanged = !bChanged;  
  25.                 }  
  26.             }  
  27.         }.start();  
  28.     }  
  29.   
  30. }  


程序输出!=，而后立刻退出。

 

可是，不少状况下，用不用volatile，感受不出什么区别，何时要用volatile呢？看看JDK里使用volatile的类。

好比java.util.regex.Pattern里的变量：

 
  1. private transient volatile boolean compiled = false;  


还有，java.lang.System的变量：

  1. private static volatile Console cons = null;  


通常就是初始化的时候，须要用到volatile。

 

java.util.Scanner里的变量，如：

  1. private static volatile Pattern boolPattern;  
  2. private static volatile Pattern separatorPattern;  
  3. private static volatile Pattern linePattern;  


初始化boolPattern的代码：

 
  1. private static Pattern boolPattern() {  
  2.         Pattern bp = boolPattern;  
  3.         if (bp == null)  
  4.             boolPattern = bp = Pattern.compile(BOOLEAN_PATTERN,  
  5.                                           Pattern.CASE_INSENSITIVE);  
  6.         return bp;  
  7. }  

 

 

上面的状况，可使用synchronized来对boolPattern加锁，可是synchronized开销比volatile大，volatile可以胜任上面的工做。

 

volatile不保证原子操做，因此，很容易读到脏数据。

 

使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，没必要使用。

总结

      在编写多线程程序中使用volatile的关键四点：

      1.将全部的共享对象声明为volatile；

      2.不要将volatile直接做用于基本类型；

      3.当定义了共享类的时候，用volatile成员函数来保证线程安全；

      4.多多理解和使用volatile和LockingPtr！（强烈建议）

 

转自：http://blog.csdn.net/jingxuewang110/article/details/6759044

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程