volatile关键字(轻量级锁)

目录

一、volatile出现背景

二、JMM概述

2.1、JMM的规定

 三、volatile的特性

3.1、可见性

 3.1.1、举例说明

 3.1.2、总结

3.2、无法保证原子性

3.2.1、举例说明

3.2.2、分析

3.2.3、使用volatile对原子性测试

 3.2.4、使用锁机制

 3.2.5、总结

3.3、禁止指令重排序

 四、volatile的内存语义

4.1、volatile 与 static

五、总结


一、volatile出现背景

        我们在写项目的时候,有时会使用多线程。为了保证一部分线程之间的通信,所以需要线程中的一些变量具有可见性。

说到线程可见性,对于Java而言,有两种方法实现:volatile和synchronized。

需要注意的是:volatile只用来保证该变量对所有线程的可见性,但不保证原子性。

        虽然加锁同样能解决共享变量不可见性的问题,但是加锁和锁的释放过程都是会有性能消耗的,所以在解决共享变量不可见性的问题时,我们首选 volatile关键字。

二、JMM概述

        JMM就是Java内存模型(Java Memory Model),是Java虚拟机规范的一种内存模型,屏蔽掉各种硬件和操作系统的内存访问差异,以实现让Java程序在各种平台下都能达到一致的并发效果。

        Java内存模型规定了Java程序的变量(包括实例变量,静态变量,但是不包括局部变量和方法参数)全部存储在主内存中,定义了各种变量(线程的共享变量)的访问规则,以及在JVM中将变量存储到主内存与从主内存读取变量的底层细节。

2.1、JMM的规定

  • 所有共享变量都存在于主内存(包括实例变量,静态变量,但是不包括局部变量和方法参数),因为局部变量是线程私有,不存在竞争问题。
  • 每个线程都有自己的工作内存,所需要的变量是主内存中的副本。
  • 线程对变量的读、写操作都只能在工作内存中完成,不能直接参与读写主内存的变量。
  • 不同的线程也不能去直接访问不同线程的工作内存的变量,线程间的变量传递需要通过主内存来中转完成。

volatile关键字(轻量级锁)_第1张图片

 三、volatile的特性

3.1、可见性

        volatile可以保证线程的可见性,即当多个线程访问同一个变量的时候,此变量发生改变,其他线程也能实时获得到这个修改的值。

        在java中,变量都会被放在堆内存(所有线程共享的内存)中,多个线程对共享内存是不可见的,当每个线程去获取这个变量的值时,实际上是copy一份副本在线程自身的工作内存中。

volatile关键字(轻量级锁)_第2张图片

 3.1.1、举例说明

        我们将main作为主线程,MyThread为子线程。在子线程中定义一个共享变量flag,主线程会去访问这个共享变量。在不加volatile的时候,flag在主线程读到的永远是为false,因为两个线程是不可见的。

public class Test {
    public static void main(String[] args) { // 主线程
        MyThread my = new MyThread();
        my.start();
        while (true) {
            if (my.isFlag()) System.out.println("进入等待...");
        }
    }
}

class MyThread extends Thread { // 子线程
    private volatile boolean flag = false;
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        flag = true;
        System.out.println("flag 修改完毕!");
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

        实际上是已经修改了的,只是线程读的都是自己的工作内存中的数据,然而,要解决这个问题,可以使用synchronized加锁和volatile修饰共享变量来解决,这两种都能让主线程拿到子线程修改的变量的值。

synchronized (my) {
    if (my.isFlag()) System.out.println("进入等待...");
}

        加了synchronized锁,首先该线程会获得锁对象,接着会去清空工作内存,再从主内存中copy一份最新的值到工作变量中,接着执行代码, 打印输出,最后释放锁。

volatile关键字(轻量级锁)_第3张图片

 

        当然还能使用volatile关键字去修饰共享变量。一开始子线程从主内存中获取变量的副本到自己的工作内存,进行改值,此时还未写回主内存,主线程从主内存获取的变量的值也是一开始的初始值,等到子线程写回到主内存时,接下来其他线程的工作内存中此变量的副本将会失效,也就是类似于监听。在需要对此变量进行操作的时候,将会到主内存获取新的值保存到线程自身的工作内存中,从而确保了数据的一致。

volatile关键字(轻量级锁)_第4张图片

 3.1.2、总结

        volatile能够保证不同线程对共享变量的可见性,也就是修改过的volatile修饰的共享变量只要被写回到主内存中,其他线程就能够马上看到最新的数据。

        当一个线程对volatile修饰的变量进行写的操作时候,JMM会立即把该线程自身的工作内存的共享变量刷新到主内存中。

        当对线程进行读操作的时候,JMM会立即把当前线程自身的工作内存设置无效,从而从主内存中去获取共享变量的数据。

3.2、无法保证原子性

原子性指的是一项操作要么都执行,要么都不执行,中途不允许中断也不受其他线程干扰。

3.2.1、举例说明

        我们看以下案例代码,简单描述一下,AutoAccretion是一个线程类,里面定义了一个共享变量count,并去执行1万次的自增,在main线程中调用多线程去执行自增。我们所期望的结果是最终count的值是1000000,因为每个线程自增1万次,一共100个线程。

public class Test{
    public static void main(String[] args) {
        Runnable thread = new AutoAccretion();
        for (int i = 1; i <= 100; i++) {
            new Thread(thread, "线程" + i).start();
        }
    }
}

class AutoAccretion implements Runnable {
    private int count = 0;
    @Override
    public void run() {
        for (int i = 1; i <= 10000; i++) {
            count++;
            System.out.println(Thread.currentThread().getName() + "count ==> " + count);
        }
    }
}

3.2.2、分析

        count++操作首先会从主内存中拷贝变量副本到工作内存中,在工作内存中进行自增操作,最后将工作内存的数据写回主内存中。运行之后会发现,count的值是没办法到达1百万的。主要原因是count++自增操作并不是原子性的,也就是说在进行count++的时候可能被其他线程打断。

        当线程1拿到count=0,进行自增后count=1,但是还没写到主内存,线程2获取的数据可能也是count=0,经过自增count=1,两者在写回内存,就会导致数据的错误。

3.2.3、使用volatile对原子性测试

现在通过volatile去修饰共享变量,运行之后,发现依然没办法达到一百万。

volatile关键字(轻量级锁)_第5张图片

 3.2.4、使用锁机制

        通过使用synchronized锁对代码快进行加锁,从而确保原子性,确保某个线程对count进行操作不受其他线程的干扰。

class AutoAccretion implements Runnable {
    private volatile int count = 0; // 并发下可见性
    @Override
    public void run() {
        synchronized (this) {
            for (int i = 1; i <= 10000; i++) {
                count++;
                System.out.println(Thread.currentThread().getName() + "count ==> " + count);
            }
        }
    }
}

通过验证可以知道能够实现原子性。

volatile关键字(轻量级锁)_第6张图片

 3.2.5、总结

        在多线程下,volatile关键字可以保证共享变量的可见性,但是不能保证对变量操作的原子性,因此,在多线程下即使加了volatile修饰的变量也是线程不安全的。要保证原子性就得通过加锁的机制。

        除了这个方法,Java还能用过原子类(java.util.concurrent.atomic包) 来保证原子性。

3.3、禁止指令重排序

1、什么是指令重排序

指令重排序:为了提高程序性能,编译器和处理器会对代码指令的执行顺序进行重排序。

良好的内存模型实际上会通过软件和硬件一同尽可能提高执行效率。JMM对底层约束尽量减少,在执行程序时,为了提高性能,编译器和处理器会对指令进行重排序。

一般重排序有以下三种:

  • 编译器优化的重排序:编译器在不改变单线程程序语义可以对执行顺序进行排序。
  • 指令集并行的重排序:如果指令不存在相互依赖,那么指令可以改变执行的顺序,从而能够减少load/store操作。
  • 内存系统的重排序:处理器使用缓存和读/写缓存区,使得加载和存储操作是乱序执行的。

2、重排序怎么提高执行速度

        在不改变结果的时候,对执行进行重排序,可以提高处理速度。重排序后能够使处理指令执行的更少,减少指令操作。

3、重排序的问题所在

        由于重排序,直接可能带来的问题就是导致最终的数据不对,通过以下例子来看,如果执行的顺序不同,最终得到的结果是不一样的。

public class Test {
    public static int a = 0, b = 0;
    public static int i = 0, j = 0;

    public static void main(String[] args) throws InterruptedException {
        int count = 0;
        while (true) {
            count++;
            // 初始化
            a = 0;
            b = 0;
            i = 0;
            j = 0;
            Thread one = new Thread(new Runnable() {
                @Override
                public void run() {
                    a = 1;
                    i = b;
                }
            });
            Thread two = new Thread(new Runnable() {
                @Override
                public void run() {
                    b = 1;
                    j = a;
                }
            });
            one.start();
            two.start();
            one.join(); // 确保线程都执行完毕
            two.join();
            System.out.println("第" + count + "次线程执行:i = " + i + ", j = " + j );
            if (i == 0 && j == 0) return;
        }
    }
}

        正常当线程都执行结束之后,最后得到的值应该是i=1, j=1。通过不断的循环执行可以看到,出现的结果会出错,当先执行了j=a(此时a=0)在执行了a=1,i=b(此时b=0),b=1,最后就会导致i=0,j=0

volatile关键字(轻量级锁)_第7张图片

 4、volatile禁止指令重排序

        使用volatile可以实现禁止指令重排序,从而确保并发安全,那么volatile是如何实现禁止指令重排序呢?就是通过使用内存屏障(Memory Barrier)。

5、内存屏障(Memory Barrier) 作用

  • 内存屏障****能够阻止屏障两侧的指令重排序,能够让cpu或者编译器在内存上的访问是有序的。
  • 强制把写缓冲区/高速缓存中的脏数据写回主内存,或让缓存相应的数据失效。他是一种cpu指令,用来控制特定情况下的重排序和内存可见性问题。

6、volatile内存屏障的插入策略

硬件层的内存屏障(Memory Barrier)有Load Barrier 和 Store Barrier即读屏障和写屏障。

Java内存屏障

  • StoreStore屏障:确保在该屏障之后的第一个写操作之前,屏障前的写操作对其他处理器可见(刷新到内存)。
  • StoreLoad屏障:确保写操作对其他处理器可见(刷新到内存)之后才能读取屏障后读操作的数据到缓存。
  • LoadLoad屏障:确保在该屏障之后的第一个读操作之前,一定能先加载屏障前的读操作对应的数据。
  • LoadStore屏障:确保屏障后的第一个写操作写出的数据对其他处理器可见之前,屏障前的读操作读取的数据一定先读入缓存。

        在volatile修饰的变量进行写操作时候,会使用StoreStore屏障和StoreLoad屏障,进行对volatile变量读操作会在之后使用LoadLoad屏障和LoadStore屏障。

volatile关键字(轻量级锁)_第8张图片

 四、volatile的内存语义

内存语义可以理解为 volatile 在执行计算时,内存中的要实现的功能与规则:

  • 一个 volatile 变量时,JMM 会把该线程对应的本地内存中的共享变量值刷新到主内存。
  • 一个 volatile 变量时,JMM 会把该线程对应的本地内存置为无效,并从主内存中读取共享变量。

4.1、volatile 与 static

  • static 修饰的变量:多实例间,保证变量的唯一性。但是没有可见性和原子性的保证。
  • volatile 修饰的变量:多实例间,变量没有唯一性。但是能保证线程可见性,不保证原子性。

所以,static volatile 修饰的变量就是多实例间的唯一性,以及线程间的可见性。

五、总结

  • 适用场景:某个属性被多个线程共享,其中有一个线程修改了此属性,其他线程可以立即得到修改后的值,比如 booleanflag;或者作为触发器,实现轻量级同步
  • volatile 变量的读写操作都是无锁的,低成本的。它不能替代 synchronized,因为它没有提供原子性和互斥性。
  • volatile 只能作用于属性,我们用volatile修饰属性,这样compilers就不会对这个属性做指令重排序。
  • volatile 可以在单例双重检查中(特殊场景)实现可见性和禁止指令重排序,从而保证安全性。

你可能感兴趣的:(java,jvm,开发语言)