专栏首页王磊的博客因为我说:volatile 是轻量级的 synchronized,面试官让我回去等通知!
原创

因为我说:volatile 是轻量级的 synchronized,面试官让我回去等通知!

volatile 是并发编程的重要组成部分,也是面试常被问到的问题之一。不要向小强那样,因为一句:volatile 是轻量级的 synchronized,而与期望已久的大厂失之交臂。

volatile 有两大特性:保证内存的可见性和禁止指令重排序。那什么是可见性和指令重排呢?接下来我们一起来看。

内存可见性

要了解内存可见性先要从 Java 内存模型(JMM)说起,在 Java 中所有的共享变量都在主内存中,每个线程都有自己的工作内存,为了提高线程的运行速度,每个线程的工作内存都会把主内存中的共享变量拷贝一份进行缓存,以此来提高运行效率,内存布局如下图所示:

内存可见性.png

但这样就会产生一个新的问题,如果某个线程修改了共享变量的值,其他线程不知道此值被修改了,就会发生两个线程值不一致的情况,我们用代码来演示一下这个问题。

public class VolatileExample {
    // 可见性参数
    private static boolean flag = false;

    public static void main(String[] args) {
		new Thread(() -> {
            try {
                // 暂停 0.5s 执行
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag = true;
            System.out.println("flag 被修改成 true");
        }).start();
        
        // 一直循环检测 flag=true
        while (true) {
            if (flag) {
                System.out.println("检测到 flag 变为 true");
                break;
            }
        }
    }
}

以上程序的执行结果如下:

flag 被修改成 true

我们会发现永远等不到 检测到 flag 变为 true 的结果,这是因为非主线程更改了 flag=true,但主线程一直不知道此值发生了改变,这就是内存不可见的问题。

内存的可见性是指线程修改了变量的值之后,其他线程能立即知道此值发生了改变。

我们可以使用 volatile 来修饰 flag,就可以保证内存的可见性,代码如下:

public class VolatileExample {
    // 可见性参数
    private static volatile boolean flag = false;

    public static void main(String[] args) {
		new Thread(() -> {
            try {
                // 暂停 0.5s 执行
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            flag = true;
            System.out.println("flag 被修改成 true");
        }).start();
        
        // 一直循环检测 flag=true
        while (true) {
            if (flag) {
                System.out.println("检测到 flag 变为 true");
                break;
            }
        }
    }
}

以上程序的执行结果如下:

检测到 flag 变为 true flag 被修改成 true

指令重排

指令重排是指在执行程序时,编译器和处理器常常会对指令进行重排序,已到达提高程序性能的目的。

比如小强要去图书馆还上次借的书,随便再借一本新书,而此时室友小王也想让小强帮他还一本书,未发生指令重排的做法是,小强先把自己的事情办完,再去办室友的事,这样显然比较浪费时间,还有一种做法是,他先把自己的书和小王的书一起还掉,再给自己借一本新书,这就是指令重排的意义。

但指令重排不能保证指令执行的顺序,这就会造成新的问题,如下代码所示:

public class VolatileExample {
    // 指令重排参数
    private static int a = 0, b = 0;
    private static int x = 0, y = 0;

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < Integer.MAX_VALUE; i++) {
            Thread t1 = new Thread(() -> {
                // 有可能发生指令重排,先 x=b 再 a=1
                a = 1;
                x = b;
            });
            Thread t2 = new Thread(() -> {
                // 有可能发生指令重排,先 y=a 再 b=1
                b = 1;
                y = a;
            });
            t1.start();
            t2.start();
            t1.join();
            t2.join();
            System.out.println("第 " + i + "次,x=" + x + " | y=" + y);
            if (x == 0 && y == 0) {
                // 发生了指令重排
                break;
            }
            // 初始化变量
            a = 0;
            b = 0;
            x = 0;
            y = 0;
        }
    }
}

以上程序执行结果如下所示:

指令重排.png

可以看出执行到 48526 次时发生了指令重排,y 就变成了非正确值 0,显然这不是我们想要的结果,这个时候就可以使用 volatile 来禁止指令重排。

以上我们通过代码的方式演示了指令重排和内存可见性的问题,接下来我们用代码来演示一下 volatile 同步方式的问题。

volatile 非同步方式

首先,我们使用 volatile 修饰一个整数变量,再启动两个线程分别执行同样次数的 ++ 和 -- 操作,最后发现执行的结果竟然不是 0,代码如下:

public class VolatileExample {
    public static volatile int count = 0; // 计数器
    public static final int size = 100000; // 循环测试次数

    public static void main(String[] args) {
        // ++ 方式
        Thread thread = new Thread(() -> {
            for (int i = 1; i <= size; i++) {
                count++;
            }
        });
        thread.start();
        // -- 方式
        for (int i = 1; i <= size; i++) {
            count--;
        }
        // 等所有线程执行完成
        while (thread.isAlive()) {}
        System.out.println(count); // 打印结果
    }
}

以上程序执行结果如下:

1065

可以看出,执行结果并不是我们期望的结果 0,我们把以上代码使用 synchronized 改造一下:

public class VolatileExample {
    public static int count = 0; // 计数器
    public static final int size = 100000; // 循环测试次数

    public static void main(String[] args) {
        // ++ 方式
        Thread thread = new Thread(() -> {
            for (int i = 1; i <= size; i++) {
                synchronized (VolatileExample.class) {
                    count++;
                }
            }
        });
        thread.start();
        // -- 方式
        for (int i = 1; i <= size; i++) {
            synchronized (VolatileExample.class) {
                count--;
            }
        }
        // 等所有线程执行完成
        while (thread.isAlive()) {}
        System.out.println(count); // 打印结果
    }
}

这次执行的结果变成了我们期望的值 0。

这说明 volatile 只是轻量级的线程可见方式,并不是轻量级的同步方式,所以并不能说 volatile 是轻量级的 synchronized,终于知道为什么面试官让我回去等通知了。

volatile 使用场景

既然 volatile 只能保证线程操作的可见方式,那它有什么用呢?

volatile 在多读多写的情况下虽然一定会有问题,但如果是一写多读的话使用 volatile 就不会有任何问题。volatile 一写多读的经典使用示例就是 CopyOnWriteArrayList,CopyOnWriteArrayList 在操作的时候会把全部数据复制出来对写操作加锁,修改完之后再使用 setArray 方法把此数组赋值为更新后的值,使用 volatile 可以使读线程很快的告知到数组被修改,不会进行指令重排,操作完成后就可以对其他线程可见了,核心源码如下:

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    
    private transient volatile Object[] array;
    
	final void setArray(Object[] a) {
        array = a;
    }	
    //...... 忽略其他代码
}

总结

本文我们通过代码的方式演示了 volatile 的两大特性,内存可见性和禁止指令重排,使用 ++ 和 -- 的方式演示了 volatile 并非轻量级的同步方式,以及 volatile 一写多读的经典使用案例 CopyOnWriteArrayList。

更多 Java 原创文章,请关注我微信公众号 「Java中文社群」

原创声明,本文系作者授权云+社区发表,未经许可,不得转载。

如有侵权,请联系 yunjia_community@tencent.com 删除。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 因为我说:volatile 是轻量级的 synchronized,面试官让我回去等通知!

    volatile 有两大特性:保证内存的可见性和禁止指令重排序。那什么是可见性和指令重排呢?接下来我们一起来看。

    Java中文社群_老王
  • react native android6+拍照闪退或重启的解决方案

    前言 android 6+权限使用的时候需要动态申请,那么在使用rn的时候要怎么处理拍照权限问题呢?本文提供的是一揽子rn操作相册、拍照的解决方案,请看正文...

    Java中文社群_老王
  • Java核心(三)并发中的线程同步与锁

    乐观锁、悲观锁、公平锁、自旋锁、偏向锁、轻量级锁、重量级锁、锁膨胀...难理解?不存的!来,话不多说,带你飙车。

    Java中文社群_老王
  • 因为我说:volatile 是轻量级的 synchronized,面试官让我回去等通知!

    volatile 有两大特性:保证内存的可见性和禁止指令重排序。那什么是可见性和指令重排呢?接下来我们一起来看。

    Java中文社群_老王
  • 关于线程可见性一个“诡异”的问题

    如果执行上面的代码,大多人可能觉得会死循环,因为这里没有任何的同步策略,比如synchronized,Lock,atomic,volatile等关键字,也就是说...

    我是攻城师
  • Java 同步 synchronized与lock

    实现线程同步一个使synchronized关键字,一个是通过对象lock. Lock 在jdk 1.5才出现的,在一定程度上缓解了synchronized同...

    张凝可
  • 多线程之线程安全

       线程是越多越好吗?答案否,线程太多的话,会造成CPU频繁的切换反而会造成很多线程处于等待状态。除了浪费资源和效率之外,多线程带来的其他风险:安全、死锁等 ...

    OPice
  • 玩机器学习要知道哪些开源数据库?

    开发 AI 和机器学习系统从来没有像现在这样方便。 类似于 TensorFlow、Torch 和 Spark 这样的开源工具,在 AI 开发者群体中已是无处不在...

    AI研习社
  • Java性能测试中两种锁的实现

    同步是使所有并发线程在执行中保持同步的过程。同步避免了由于共享内存视图不一致而导致的内存一致性错误。当方法被声明为同步时,该线程持有监视器或锁定对象为这个方法的...

    八音弦
  • CentOS 7 下使用yum安装MySQL5.7.20 最简单 图文详解

    CentOS7默认数据库是mariadb, 但是 好多用的都是mysql ,但是CentOS7的yum源中默认好像是没有mysql的。

    chenchenchen

扫码关注云+社区

领取腾讯云代金券