Java并发编程(二) volatile

volatile变量的特性

保证可见性,不保证原子性:

  • 当写一个volatile变量时,JMM会把该线程本地内存中的变量强制刷新到主内存中去;
  • 这个写操作会导致其他线程中的volatile变量缓存无效。

禁止指令重排,我们回顾一下,重排序需要遵守一定规则:

  • 重排序操作不会对存在数据依赖关系的操作进行重排序。比如:a=1;b=a; 这个指令序列,由于第二个操作依赖于第一个操作,所以在编译时和处理器运行时这两个操作不会被重排序。
  • 重排序是为了优化性能,但是不管怎么重排序,单线程下程序的执行结果不能被改变。比如:a=1;b=2;c=a+b这三个操作,第一步(a=1)和第二步(b=2)由于不存在数据依赖关系, 所以可能会发生重排序,但是c=a+b这个操作是不会被重排序的,因为需要保证最终的结果一定是c=a+b=3。
volatile禁止指令重排规则

使用volatile关键字修饰共享变量便可以禁止这种重排序。若用volatile修饰共享变量,在编译时,会在指令序列中插入内存屏障来禁止特定类型的处理器重排序,volatile禁止指令重排序也有一些规则:

  • 当程序执行到volatile变量的读操作或者写操作时,在其前面的操作的更改肯定全部已经进行,且结果已经对后面的操作可见;在其后面的操作肯定还没有进行;
  • 在进行指令优化时,不能将对volatile变量访问的语句放在其后面执行,也不能把volatile变量后面的语句放到其前面执行。

即执行到volatile变量时,其前面的所有语句都执行完,后面所有语句都未执行。且前面语句的结果对volatile变量及其后面语句可见。

volatile禁止指令重排分析

示例:

class ReorderExample {
  int a = 0;
  boolean volatile flag = false;
  public void writer() {
      a = 1;                   //1
      flag = true;             //2
  }
  Public void reader() {
      if (flag) {                //3
          int i =  a * a;        //4
          System.out.println(i);
      }
  }
}

根据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规则,其实就是重排序规则建立的代码前后依赖关系。

温馨提示:这里大家可能会有疑问,1、3的规则我理解,但是对于2,为什么“2 happens before 3”,还记得前面讲的“内存模型”么?因为你对变量flag指定了volatile,所以当线程A执行完后,变量flag=true会直接刷到内存中,然后B马上可见,所以说2一定是在3前面,不可能因为重排序,导致3在2前面执行。(然后还要提示一下,这里执行时有个前提条件,就是线程A执行完,才能执行线程B里面的逻辑,因为线程A不执行完,flag一直是false,线程B根本就进不到主流程,所以你也可以直接理解为线程A执行完后,再执行线程B,才有这么个先后关系。)

上述happens before关系的图形化表现形式如下:

在这里插入图片描述

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

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

volatile的原理和实现机制

前面讲述了源于volatile关键字的一些使用,下面我们来探讨一下volatile到底如何保证可见性和禁止指令重排序的。

下面这段话摘自《深入理解Java虚拟机》:

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

lock前缀指令实际上相当于一个内存屏障(也成内存栅栏),内存屏障会提供3个功能:

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

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

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

使用volatile关键字的场景

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

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

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

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

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

举例:

//单例模式双重锁校验

public class SingTest {

    private volatile static SingTest singTest = null;

    private SingTest() {
    }

    public SingTest getSingTest() {      //1
        if (singTest == null) {      //2
            synchronized (SingTest.class) {      //3
                if (null == singTest) {       //4
                    singTest = new SingTest(); //5
                }

            }
        }
        return singTest;
    }
}

在并发情况下,如果没有volatile关键字,在第5行会出现问题。singTest= new SingTest();可以分解为3行伪代码:

a. memory = allocate() //分配内存
b. ctorInstanc(memory) //初始化对象
c. singTest = memory   //设置instance指向刚分配的地址

上面的代码在编译运行时,可能会出现重排序从a-b-c排序为a-c-b。在多线程的情况下会出现以下问题。当线程A在执行第5行代码时,B线程进来执行到第2行代码。假设此时A执行的过程中发生了指令重排序,即先执行了a和c,没有执行b。那么由于A线程执行了c导致singTest指向了一段地址,所以B线程判断singTest 不为null,会直接跳到第6行并返回一个未初始化的对象。

volatile不适用场景
volatile不适合复合操作
public class VolatileTest {

    public volatile int inc = 0;
    public void increase() {
        inc++;
    }
    public static void main(String[] args) throws InterruptedException {
        final VolatileTest test = new VolatileTest();
      Thread thread =  new Thread(()->{
                for (int i = 0; i < 3000; i++) {
                    test.increase();
                }
        });
        Thread thread1 =  new Thread(()->{
                for (int i = 0; i < 3000; i++) {
                    test.increase();
                }
        });
        Thread thread2 =  new Thread(()->{
                for (int i = 0; i < 3000; i++) {
                    test.increase();
                }

        });
        thread.start();
        thread1.start();
        thread2.start();
        thread.join();
        thread1.join();
        thread2.join();
        System.out.println("inc output:" + test.inc);
    }
}

执行结果:

inc output:8437

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

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

这里面就有一个误区了,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 VolatileTest {

    public volatile int inc = 0;

    public void increase() {
        inc++;
    }

    public static void main(String[] args) throws InterruptedException {
        final VolatileTest test = new VolatileTest();
        Thread thread = new Thread(() -> {
            synchronized (VolatileTest.class) {
                for (int i = 0; i < 3000; i++) {
                    test.increase();
                }
            }
        });
        Thread thread1 = new Thread(() -> {
            synchronized (VolatileTest.class) {
                for (int i = 0; i < 3000; i++) {
                    test.increase();
                }
            }
        });
        Thread thread2 = new Thread(() -> {
            synchronized (VolatileTest.class) {
                for (int i = 0; i < 3000; i++) {
                    test.increase();
                }
            }
        });
        thread.start();
        thread1.start();
        thread2.start();
        thread.join();
        thread1.join();
        thread2.join();
        System.out.println("inc output:" + test.inc);
    }
}

执行结果:

inc output:9000

采用Lock:

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class VolatileTest {

    public volatile int inc = 0;
    Lock lock = new ReentrantLock();
    public void increase() throws InterruptedException {
        lock.lock();
        inc++;
        lock.unlock();
    }

    public static void main(String[] args) throws InterruptedException {
        final VolatileTest test = new VolatileTest();
        Thread thread = new Thread(() -> {
//            synchronized (VolatileTest.class) {
                for (int i = 0; i < 3000; i++) {
                    try {
                        test.increase();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
//            }
        });
        Thread thread1 = new Thread(() -> {
//            synchronized (VolatileTest.class) {
                for (int i = 0; i < 3000; i++) {
                    try {
                        test.increase();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
//            }
        });
        Thread thread2 = new Thread(() -> {
//            synchronized (VolatileTest.class) {
                for (int i = 0; i < 3000; i++) {
                    try {
                        test.increase();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
//            }
        });
        thread.start();
        thread1.start();
        thread2.start();
        thread.join();
        thread1.join();
        thread2.join();
        System.out.println("inc output:" + test.inc);
    }
}

执行结果:

inc output:9000

采用AtomicInteger:

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class VolatileTest {

    public AtomicInteger inc = new AtomicInteger();
//    Lock lock = new ReentrantLock();
    public void increase() throws InterruptedException {
//        lock.lock();
        inc.getAndIncrement();
//        lock.unlock();
    }

    public static void main(String[] args) throws InterruptedException {
        final VolatileTest test = new VolatileTest();
        Thread thread = new Thread(() -> {
//            synchronized (VolatileTest.class) {
                for (int i = 0; i < 3000; i++) {
                    try {
                        test.increase();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
//            }
        });
        Thread thread1 = new Thread(() -> {
//            synchronized (VolatileTest.class) {
                for (int i = 0; i < 3000; i++) {
                    try {
                        test.increase();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
//            }
        });
        Thread thread2 = new Thread(() -> {
//            synchronized (VolatileTest.class) {
                for (int i = 0; i < 3000; i++) {
                    try {
                        test.increase();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
//            }
        });
        thread.start();
        thread1.start();
        thread2.start();
        thread.join();
        thread1.join();
        thread2.join();
        System.out.println("inc output:" + test.inc);
    }
}

执行结果:

inc output:9000
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值