欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

详解Java线程编程中的volatile关键字的作用

程序员文章站 2024-03-07 16:46:21
1.volatile关键字的两层语义   一旦一个共享变量(类的成员变量、类的静态成员变量)被volatile修饰之后,那么就具备了两层语义:   1)保证了不同线程对...

1.volatile关键字的两层语义

  一旦一个共享变量(类的成员变量、类的静态成员变量)被volatile修饰之后,那么就具备了两层语义:

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

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

  先看一段代码,假如线程1先执行,线程2后执行:

//线程1
boolean stop = false;
while(!stop){
  dosomething();
}
 
//线程2
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特性的一个好方法是:把对volatile变量的单个读/写,看成是使用同一个监视器锁对这些单个读/写操作做了同步。下面我们通过具体的示例来说明,请看下面的示例代码:

class volatilefeaturesexample {
  volatile long vl = 0l; //使用volatile声明64位的long型变量

  public void set(long l) {
    vl = l;  //单个volatile变量的写
  }

  public void getandincrement () {
    vl++;  //复合(多个)volatile变量的读/写
  }


  public long get() {
    return vl;  //单个volatile变量的读
  }
}

假设有多个线程分别调用上面程序的三个方法,这个程序在语意上和下面程序等价:

class volatilefeaturesexample {
  long vl = 0l;        // 64位的long型普通变量

  public synchronized void set(long l) {   //对单个的普通 变量的写用同一个监视器同步
    vl = l;
  }

  public void getandincrement () { //普通方法调用
    long temp = get();      //调用已同步的读方法
    temp += 1l;         //普通写操作
    set(temp);          //调用已同步的写方法
  }
  public synchronized long get() { 
  //对单个的普通变量的读用同一个监视器同步
    return vl;
  }
}

如上面示例程序所示,对一个volatile变量的单个读/写操作,与对一个普通变量的读/写操作使用同一个监视器锁来同步,它们之间的执行效果相同。

监视器锁的happens-before规则保证释放监视器和获取监视器的两个线程之间的内存可见性,这意味着对一个volatile变量的读,总是能看到(任意线程)对这个volatile变量最后的写入。

3.volatile写-读建立的happens before关系

上面讲的是volatile变量自身的特性,对程序员来说,volatile对线程的内存可见性的影响比volatile自身的特性更为重要,也更需要我们去关注。

从jsr-133开始,volatile变量的写-读可以实现线程之间的通信。

从内存语义的角度来说,volatile与监视器锁有相同的效果:volatile写和监视器的释放有相同的内存语义;volatile读与监视器的获取有相同的内存语义。

请看下面使用volatile变量的示例代码:

class volatileexample {
  int a = 0;
  volatile boolean flag = false;

  public void writer() {
    a = 1;          //1
    flag = true;        //2
  }

  public void reader() {
    if (flag) {        //3
      int i = a;      //4
      ……
    }
  }
}

假设线程a执行writer()方法之后,线程b执行reader()方法。根据happens before规则,这个过程建立的happens before 关系可以分为两类:

根据程序次序规则,1 happens before 2; 3 happens before 4。
根据volatile规则,2 happens before 3。
根据happens before 的传递性规则,1 happens before 4。
上述happens before 关系的图形化表现形式如下:

详解Java线程编程中的volatile关键字的作用

在上图中,每一个箭头链接的两个节点,代表了一个happens before 关系。黑色箭头表示程序顺序规则;橙色箭头表示volatile规则;蓝色箭头表示组合这些规则后提供的happens before保证。

这里a线程写一个volatile变量后,b线程读同一个volatile变量。a线程在写volatile变量之前所有可见的共享变量,在b线程读同一个volatile变量后,将立即变得对b线程可见。

4.volatile写-读的内存语义

volatile写的内存语义如下:

当写一个volatile变量时,jmm会把该线程对应的本地内存中的共享变量刷新到主内存。
以上面示例程序volatileexample为例,假设线程a首先执行writer()方法,随后线程b执行reader()方法,初始时两个线程的本地内存中的flag和a都是初始状态。下图是线程a执行volatile写后,共享变量的状态示意图:

详解Java线程编程中的volatile关键字的作用

如上图所示,线程a在写flag变量后,本地内存a中被线程a更新过的两个共享变量的值被刷新到主内存中。此时,本地内存a和主内存中的共享变量的值是一致的。

volatile读的内存语义如下:

当读一个volatile变量时,jmm会把该线程对应的本地内存置为无效。线程接下来将从主内存中读取共享变量。
下面是线程b读同一个volatile变量后,共享变量的状态示意图:

详解Java线程编程中的volatile关键字的作用

如上图所示,在读flag变量后,本地内存b已经被置为无效。此时,线程b必须从主内存中读取共享变量。线程b的读取操作将导致本地内存b与主内存中的共享变量的值也变成一致的了。

如果我们把volatile写和volatile读这两个步骤综合起来看的话,在读线程b读一个volatile变量后,写线程a在写这个volatile变量之前所有可见的共享变量的值都将立即变得对读线程b可见。

下面对volatile写和volatile读的内存语义做个总结:

线程a写一个volatile变量,实质上是线程a向接下来将要读这个volatile变量的某个线程发出了(其对共享变量所在修改的)消息。
线程b读一个volatile变量,实质上是线程b接收了之前某个线程发出的(在写这个volatile变量之前对共享变量所做修改的)消息。
线程a写一个volatile变量,随后线程b读这个volatile变量,这个过程实质上是线程a通过主内存向线程b发送消息。

5.volatile保证原子性吗?

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

  下面看一个例子:

public class test {
  public volatile int inc = 0;
   
  public void increase() {
    inc++;
  }
   
  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.increase();
        };
      }.start();
    }
     
    while(thread.activecount()>1) //保证前面的线程都执行完
      thread.yield();
    system.out.println(test.inc);
  }
}

   大家想一下这段程序的输出结果是多少?也许有些朋友认为是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也无法保证对变量的任何操作都是原子性的。

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

  采用synchronized:

public class test {
  public int inc = 0;
  
  public synchronized void increase() {
    inc++;
  }
  
  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.increase();
        };
      }.start();
    }
    
    while(thread.activecount()>1) //保证前面的线程都执行完
      thread.yield();
    system.out.println(test.inc);
  }
}

  采用lock:

public class test {
  public int inc = 0;
  lock lock = new reentrantlock();
  
  public void increase() {
    lock.lock();
    try {
      inc++;
    } finally{
      lock.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.increase();
        };
      }.start();
    }
    
    while(thread.activecount()>1) //保证前面的线程都执行完
      thread.yield();
    system.out.println(test.inc);
  }
}

  采用atomicinteger:

public class test {
  public atomicinteger inc = new atomicinteger();
   
  public void increase() {
    inc.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.increase();
        };
      }.start();
    }
    
    while(thread.activecount()>1) //保证前面的线程都执行完
      thread.yield();
    system.out.println(test.inc);
  }
}

  在java 1.5的java.util.concurrent.atomic包下提供了一些原子操作类,即对基本数据类型的 自增(加1操作),自减(减1操作)、以及加法操作(加一个数),减法操作(减一个数)进行了封装,保证这些操作是原子性操作。atomic是利用cas来实现原子性操作的(compare and swap),cas实际上是利用处理器提供的cmpxchg指令实现的,而处理器执行cmpxchg指令是一个原子性操作。

6.volatile能保证有序性吗?

  在前面提到volatile关键字能禁止指令重排序,所以volatile能在一定程度上保证有序性。

  volatile关键字禁止指令重排序有两层意思:

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

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

  可能上面说的比较绕,举个简单的例子:

//x、y为非volatile变量
//flag为volatile变量
 
x = 2;    //语句1
y = 0;    //语句2
flag = true; //语句3
x = 4;     //语句4
y = -1;    //语句5

   由于flag变量为volatile变量,那么在进行指令重排序的过程的时候,不会将语句3放到语句1、语句2前面,也不会讲语句3放到语句4、语句5后面。但是要注意语句1和语句2的顺序、语句4和语句5的顺序是不作任何保证的。

  并且volatile关键字能保证,执行到语句3时,语句1和语句2必定是执行完毕了的,且语句1和语句2的执行结果对语句3、语句4、语句5是可见的。

  那么我们回到前面举的一个例子:

//线程1:
context = loadcontext();  //语句1
inited = true;       //语句2
 
//线程2:
while(!inited ){
 sleep()
}
dosomethingwithconfig(context);

   前面举这个例子的时候,提到有可能语句2会在语句1之前执行,那么久可能导致context还没被初始化,而线程2中就使用未初始化的context去进行操作,导致程序出错。

  这里如果用volatile关键字对inited变量进行修饰,就不会出现这种问题了,因为当执行到语句2时,必定能保证context已经初始化完毕。