Volatile关键字与线程的特性

Java中多线程情况下,每个线程对数据的处理都会有这样一个过程
先从主内存中拷贝变量到cpu缓存中,这样可能会导致,对同一数据的处理不及时,引起缓存一致性问题。
例如这样

	private static int initValue = 0;
    private final static int Max = 10;

    public static void main(String[] args) {


        new Thread("reader") {
            public void run() {
                int localValue=initValue;
                while (localValue<Max) {
                    if (initValue != localValue) {
                        System.out.println("The initValue is updated to " + initValue);
                        localValue = initValue;
                    }
                }
            }
        }.start();
        new Thread("updater"){
            @Override
            public void run() {
                int localValue=initValue;
                while(localValue<Max){
                    System.out.println("The initValue will be changed to "+(++localValue));
                    initValue=localValue;
                    try {
                        TimeUnit.MILLISECONDS.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();
    }

在这里插入图片描述
会输出这样的结果
此时我们加上volatile关键字之后,便会恢复正常。

Java语言提供了一种稍弱的同步机制,即volatile变量,用来确保将变量的更新操作通知到其他线程。当把变量声明为volatile类型后,编译器与运行时都会注意到这个变量是共享的,因此不会将该变量上的操作与其他内存操作一起重排序。volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方,因此在读取volatile类型的变量时总会返回最新写入的值。

再说Volatile关键字之前,我们要先考虑并发的三大特性:
可见性、有序性、原子性

可见性

可见性是一种复杂的属性,因为可见性中的错误总是会违背我们的直觉。通常,我们无法确保执行读操作的线程能适时地看到其他线程写入的值,有时甚至是根本不可能的事情。为了确保多个线程之间对内存写入操作的可见性,必须使用同步机制。

可见性,是指线程之间的可见性,一个线程修改的状态对另一个线程是可见的。也就是一个线程修改的结果。另一个线程马上就能看到。比如:用volatile修饰的变量,就会具有可见性。volatile修饰的变量不允许线程内部缓存和重排序,即直接修改内存。所以对其他线程是可见的。但是这里需要注意一个问题,volatile只能让被他修饰内容具有可见性,但不能保证它具有原子性。比如 volatile int a = 0;之后有一个操作 a++;这个变量a具有可见性,但是a++ 依然是一个非原子操作,也就是这个操作同样存在线程安全问题。
  volatile变量不会被缓存在寄存器或者对其他处理器不可见的地方,因此在读取volatile类型的变量时总会返回最新写入的值。
具体过程如下:

  • a. 通过总线加锁
  • b. 通过缓存一致性协议 MESI协议
  • b1.读取操作,不会做任何处理
  • b2.写入操作,发出信号通过其他cpu将cpu cache中副本置为无效状态,
  • 其他cpu在进行该变量读取的时候不得不到主内存中去再次获取

当对非 volatile 变量进行读写的时候,每个线程先从内存拷贝变量到CPU缓存中。如果计算机有多个CPU,每个线程可能在不同的CPU上被处理,这意味着每个线程可以拷贝到不同的 CPU cache 中。

而声明变量是 volatile 的,JVM 保证了每次读变量都从内存中读,跳过 CPU cache 这一步。

有序性

Java 语言提供了 volatile 和 synchronized 两个关键字来保证线程之间操作的有序性,volatile 是因为其本身包含“禁止指令重排序”的语义,synchronized 是由“一个变量在同一个时刻只允许一条线程对其进行 lock 操作”这条规则获得的,此规则决定了持有同一个对象锁的两个同步块只能串行执行。

  • (什么是指令重排序:是指CPU采用了允许将多条指令不按程序规定的顺序分开发送给各相应电路单元处理)。

Java语言提供了一种稍弱的同步机制,即volatile变量,用来确保将变量的更新操作通知到其他线程。当把变量声明为volatile类型后,编译器与运行时都会注意到这个变量是共享的,因此不会将该变量上的操作与其他内存操作一起重排序。

具体保障

  • 1)确保指令重排序时不会将内存屏障后面的排到内存屏障之前
  • 2)确保指令重排序时不会将内存屏障前面的排到内存屏障之后
  • 3)确保在执行到内存屏障修饰的指令时,前面的代码全部执行完成
  • 4)强制将线程工作内存中的的值刷新到主内存中
  • 5)写操作时,会导致其他线程(使用共享变量)工作内存中的缓存数据会失效,下一次就需要去主内存中再次读取
当一个变量定义为 volatile 之后,将具备两种特性:
  • 1.保证此变量对所有的线程的可见性,这里的“可见性”,如本文开头所述,当一个线程修改了这个变量的值,volatile 保证了新值能立即同步到主内存,以及每次使用前立即从主内存刷新。但普通变量做不到这点,普通变量的值在线程间传递均需要通过主内存(详见:Java内存模型)来完成。

  • 2.禁止指令重排序优化。有volatile修饰的变量,赋值后多执行了一个 “load addl $0x0, (%esp)”操作,这个操作相当于一个内存屏障(指令重排序时不能把后面的指令重排序到内存屏障之前的位置),只有一个CPU访问内存时,并不需要内存屏障;(什么是指令重排序:是指CPU采用了允许将多条指令不按程序规定的顺序分开发送给各相应电路单元处理)。

总而言之,volatile关键字可以保证有序性和可见性,但不能保证原子性。

原子性

原子是世界上的最小单位,具有不可分割性。比如 a=0;(a非long和double类型) 这个操作是不可分割的,那么我们说这个操作时原子操作。再比如:a++; 这个操作实际是a = a + 1;是可分割的,所以他不是一个原子操作。非原子操作都会存在线程安全问题,需要我们使用同步技术(sychronized)来让它变成一个原子操作。一个操作是原子操作,那么我们称它具有原子性。java的concurrent包下提供了一些原子类,我们可以通过阅读API来了解这些原子类的用法。比如:AtomicInteger、AtomicLong、AtomicReference等。

在 Java 中 synchronized 和在 lock、unlock 中操作保证原子性。

例如
i++;就不满足原子性
i++分为3步骤:
* 1)从主内存获取i的值,缓存到当前线程的工作内存
* 2)在线程工作内存对i进行+1
* 3)将i的最新值写入到主内存中
我们用一个代码做例子

public class MyThread {
    private static CountDownLatch countDownLatch = new CountDownLatch(10);
    public volatile  static int i = 0;
    public static void increase(){
        i++;}

    public static void main(String[] args) {
        for(int i=0; i<10; i++) {
            new Thread() {
                @Override
                public void run() {
                    for (int i = 0; i < 1000; i++) {
                        increase();
                    }
                    //将计数器的值减1
                    try {
                        TimeUnit.MILLISECONDS.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    countDownLatch.countDown();
                }
            }.start();
        }
        //调用await方法使得该线程阻塞,直到计数器为0才会执行
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(i);
    }
}

如果我们改代码没有任何安全性问题,那么一定会最后的结果应该是10000
但是
在这里插入图片描述
为什么会这样
我们分析一下
现在有两个线程要对同一个静态变量i操作,此时run方法体中只有一个i++;
此时线程A进行操作,他在第二步完成后还没有将最新值写入内存中,突然中断切换到线程B操作,线程B又会将没有更新的值取出来,加一然后写入内存,此时在切换会线程A,线程A就会将同样的值在写入一次。
这一来一回,就导致会缺少许多的次数。

展开阅读全文

Windows版YOLOv4目标检测实战:训练自己的数据集

04-26
©️2020 CSDN 皮肤主题: 游动-白 设计师: 上身试试 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值