Java多线程并发编程 Volatile关键字

volatile 关键字是一个神秘的关键字，也许在 J2EE 上的 JAVA 程序员会了解多一点，但在 Android 上的 JAVA 程序员大多不了解这个关键字。只要稍了解不当就好容易导致一些并发上的错误发生，例如好多人把 volatile 理解成变量的锁。（并不是）

volatile 的特性：

具备可见性

保证不同线程对被 volatile 修饰的变量的可见性。

有一被 volatile 修饰的变量 i，在一个线程中修改了此变量 i，对于其他线程来说 i 的修改是立即可见的。

如：

volatile int i = 0；// 语句 1
i++; // 语句 2

语句 2 执行完后，i 最新的值会立即被强制更新到主内存（共享内存），并通知其他缓存了 i 的线程，令其他线程的工作内存里的 i 失效，从而需重新到主内存读取最新的值。

具备有序性

被 volatile 修饰的变量，不会被优化排序。

解决的问题详见：Java 多线程并发编程 并发三大要素 的 三、有序性。

当编译器在给程序优化排序时，若遇到 volatile 变量的读操作或者写操作，则会保证在其前面的操作全部进行完成，且结果对后面的操作可见；并且保证在其后面的操作没有进行。

不具备原子性

volatile 不具备原子性，所以它是线程不安全的。

实验：

// 一个单例的实现
public class SingletonTest {

  private static volatile SingletonTest mInstance = null;

  private SingletonTest() {}

  public static SingletonTest getInstance() {

    if (mInstance == null) {
      mInstance = new SingletonTest();
      System.out.println(" 初始化完成 ");
    }

    return mInstance;
  }
}

// 测试代码
public class Test {

  public static void main(String[] var0) {
    for(int i = 0; i < 20; i++){
      ThreadTest test = new ThreadTest();
      test.start();
    }
  }

  static class ThreadTest extends Thread{

    @Override
    public void run() {
      super.run();

      SingletonTest.getInstance();
    }
  }

}

结果：
每次运行都输出多个 “初始化完成”。

volatile 的解释

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

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

被 volatile 修饰的变量进行读和写操作的时候，在相应的汇编程序中都会多一句内存屏障（Memory Barrier）。

而这个 lock 就是内存屏障。

内存屏障的作用：

1、在重新优化排序时保证其后面的指令不会被排到内存屏障的前面，前面的指令也不会排到内存屏障的后面。- 有序性

2、强制对写操作后的结果（立即）刷新到主内存。

3、刷新结果到主内存时，通知并令其他线程缓存内的值过期 / 失效。

2 和 3 合起来则是可见性。

说到这里，也许会有好多人困惑，既然可见性可以保证，既然可以做到修改某个变量的值后，会刷新到主内存，并令其他线程缓存失效，为什么不能保证原子性呢？这也是我之前走进的一个困区。

继续用 i++ 来分析一下，这里面包含的指令：

从主内存读取到缓存 // 指令 1
进行运算 // 指令 2
从缓存刷新到主内存 // 指令 3
内存屏障 // 指令 4

虽然指令 4（内存屏障）功能强大，但可惜 // 指令 1、2、3 都不是具备原子性，所以导致 volatile 不具备原子性，线程不安全，不能替代锁的作用。

使用场景

如一些简单的状态标记：

volatile boolean inited = false;

// 线程 1
init(); // 语句 1
inited = true; // 语句 2

// 线程 2
while(inited){
	work(); // 语句 3
}

1、可确保语句 1 和语句 2 的执行顺序。
2、可确保执行语句 2 后，线程 2 可立即获取到最新的修改，从而执行语句 3。

赞 (0)

相关推荐

  • Java多线程并发编程 Volatile关键字

    volatile 关键字是一个神秘的关键字,也许在 J2EE 上的 JAVA 程序员会了解多一点,但在 Android 上的 JAVA 程序员大多不了解这个关键字.只要稍了解不当就好容易导致一些并发上的错误发生,例如好多人把 volatile 理解成变量的锁.(并不是) volatile 的特性: 具备可见性 保证不同线程对被 volatile 修饰的变量的可见性. 有一被 volatile 修饰的变量 i,在一个线程中修改了此变量 i,对于其他线程来说 i 的修改是立即可见的. 如: vola

  • Java多线程并发编程 Synchronized关键字

    synchronized 关键字解析 同步锁依赖于对象,每个对象都有一个同步锁. 现有一成员变量 Test,当线程 A 调用 Test 的 synchronized 方法,线程 A 获得 Test 的同步锁,同时,线程 B 也去调用 Test 的 synchronized 方法,此时线程 B 无法获得 Test 的同步锁,必须等待线程 A 释放 Test 的同步锁才能获得从而执行对应方法的代码. 综上,正确使用 synchronized 关键字可确保原子性. synchronized 关键字的特

  • Java多线程并发编程(互斥锁Reentrant Lock)

    Java 中的锁通常分为两种: 通过关键字 synchronized 获取的锁,我们称为同步锁,上一篇有介绍到:Java 多线程并发编程 Synchronized 关键字. java.util.concurrent(JUC)包里的锁,如通过继承接口 Lock 而实现的 ReentrantLock(互斥锁),继承 ReadWriteLock 实现的 ReentrantReadWriteLock(读写锁). 本篇主要介绍 ReentrantLock(互斥锁). ReentrantLock(互斥锁)

  • Java并发编程volatile关键字的作用

    日常编程中出现 volatile 关键字的频率并不高,大家可能对 volatile 关键字比较陌生,再深入一点也许是听闻 volatile 只能保证可见性而不能保证原子性,无法有效保证线程安全,于是更加避免使用 volatile ,简简单单加上synchronize关键字就完事了.本文稍微深入探讨 volatile 关键字,分析其作用及对应的使用场景. 并发编程的几个概念简述 首先简单介绍几个与并发编程相关的概念: 可见性 可见性是指变量在线程之间是否可见,JVM 中默认情况下线程之间不具备可见

  • Java并发编程——volatile关键字

    一.volatile是什么 volatile是Java并发编程中重要的一个关键字,被比喻为"轻量级的synchronized",与synchronized不同的是,volatile只能修饰变量,无法修饰方法及代码块等. 下面是使用volatile关键字实现的单例模式: public class Singleton implements Serializable { private static volatile Singleton singleton; private Singleto

  • Java 多线程并发编程_动力节点Java学院整理

    Java 多线程并发编程_动力节点Java学院整理

    一.多线程 1.操作系统有两个容易混淆的概念,进程和线程. 进程:一个计算机程序的运行实例,包含了需要执行的指令:有自己的独立地址空间,包含程序内容和数据:不同进程的地址空间是互相隔离的:进程拥有各种资源和状态信息,包括打开的文件.子进程和信号处理. 线程:表示程序的执行流程,是CPU调度执行的基本单位:线程有自己的程序计数器.寄存器.堆栈和帧.同一进程中的线程共用相同的地址空间,同时共享进进程锁拥有的内存和其他资源. 2.Java标准库提供了进程和线程相关的API,进程主要包括表示进程的jav

  • Java多线程并发编程和锁原理解析

    这篇文章主要介绍了Java多线程并发编程和锁原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 一.前言 最近项目遇到多线程并发的情景(并发抢单&恢复库存并行),代码在正常情况下运行没有什么问题,在高并发压测下会出现:库存超发/总库存与sku库存对不上等各种问题. 在运用了 限流/加锁等方案后,问题得到解决. 加锁方案见下文. 二.乐观锁 & 悲观锁 1.乐观锁 顾名思义,就是很乐观,每次去拿数据的时候都认为别人不会修改,所以不会上锁

  • Java 多线程并发编程提高数据处理效率的详细过程

    工作场景中遇到这样一个需求:根据主机的 IP 地址联动更新其他模型的相关信息.需求很简单,只涉及一般的数据库联动查询以及更新操作,然而在编码实现过程中发现,由于主机的数量很多,导致循环遍历查询.更新时花费很长的时间,调用一次接口大概需要 30-40 min 时间才能完成操作. 因此,为了有效缩短接口方法的执行时间,便考虑使用多线程并发编程方法,利用多核处理器并行执行的能力,通过异步处理数据的方式,便可以大大缩短执行时间,提高执行效率. 这里使用可重用固定线程数的线程池 FixedThreadPo

  • Java多线程并发编程 并发三大要素

    一.原子性 原子,一个不可再被分割的颗粒.原子性,指的是一个或多个不能再被分割的操作. int i = 1; // 原子操作 i++; // 非原子操作,从主内存读取 i 到线程工作内存,进行 +1,再把 i 写到朱内存. 虽然读取和写入都是原子操作,但合起来就不属于原子操作,我们又叫这种为"复合操作". 我们可以用synchronized 或 Lock 来把这个复合操作"变成"原子操作. 例子: private synchronized void increase

  • 深入探究Java多线程并发编程的要点

    关键字synchronized synchronized关键可以修饰函数.函数内语句.无论它加上方法还是对象上,它取得的锁都是对象,而不是把一段代码或是函数当作锁. 1,当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一段时间只能有一个线程得到执行,而另一个线程只有等当前线程执行完以后才能执行这块代码. 2,当一个线程访问object中的一个synchronized(this)同步代码块时,其它线程仍可以访问这个object中是其它非synchr

随机推荐