• 如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏吧

Volatile关键字&&DCL单例模式,volatile 和 synchronized 的区别

开发技术 开发技术 3周前 (09-04) 23次浏览

Volatile 英文翻译:易变的、可变的、不稳定的。

一、volatile 定义及用法

多个线程的工作内存彼此独立,互不可见,线程启动的时候,虚拟机为每个内存分配一块工作内存,不仅包含了线程内部定义的局部变量,也包含了线程所需要使用的共享变量的副本,是为了提高效率。

  • 在之前的示例中,线程不安全的问题,我们使用线程同步,也就是通过 synchronized 关键字,对操作的对象加锁,屏蔽了其他线程对这块代码的访问,从而保证安全。

  • 这里的 volatile 尝试从另一个角度解决这个问题,那就是保证变量可见,有说法将其称之为轻量级的synchronized。

volatile保证变量可见:简单来说就是,当线程 A 对变量 X 进行了修改后,在线程 A 后面执行的其他线程能够看到 X 的变动,就是保证了 X 永远是最新的。更详细的说,就是要符合以下两个规则:

  1. 线程对变量进行修改后,要立刻写回主内存;
  2. 线程对变量读取的时候,要从主内存读,而不是缓存。

另一个角度,结合指令重排序的问题,volatile修饰的内存空间,在这上面执行的指令是禁止乱序的。因此,在单例模式的 DCL 写法中,volatile是必须的元素。

1.1 示例1

private static int num = 0;
public static void main(String[] args) throws InterruptedException {
    new Thread(()->{
        while (num == 0){

        }
    }).start();

    Thread.sleep(1000);
    num = 1;
}

代码死循环,因为主线程里的 num = 1,不能及时将数据变化更新到主存,因此上面的代码 while 条件持续为真。
因此可以给变量加上 volatile

private volatile static int num = 0;

这样就在执行几秒后就会停止运行。

1.2 Double-Chec++ked-Locking

设计模式里的单例模式,如果在多线程的情况下,仍然要保证始终只有一个对象,就要进行同步和锁。

class DCL{
    private static volatile DCL instance;
    private DCL(){

    }

    public static DCL getInstance(){
        if (instance == null){//check1
            synchronized (DCL.class){
                if (instance == null){//check2
                    instance = new DCL();
                }
            }
        }
        return instance;
    }
}

双重校验锁,实现线程安全的单例锁。
volatile不能保证原子性。

1.3 原子性问题

原子操作就是这个操作要么执行完,要么不执行,不可能卡在中间。

比如 i = 2,这个指令就是具有原子性的,而 i++ 则不是,事实上 i++ 也是先拿 i,再修改,再重新赋值给 i 。

例如你让一个volatile的integer自增(i++),其实要分成3步:

1)读取volatile变量值到local;

2)增加变量的值;

3)把local的值写回,让其它的线程可见。

这3步的jvm指令为:

mov    0xc(%r10),%r8d ; Load
inc    %r8d           ; Increment
mov    %r8d,0xc(%r10) ; Store
lock addl $0x0,(%rsp) ; StoreLoad Barrier

最后一步是内存屏障。

什么是内存屏障?

内存屏障告诉CPU和编译器先于这个命令的必须先执行,后于这个命令的必须后执行,同时强制更新一次不同CPU的缓存,也就是通过这个操作,使得 volatile 关键字达到了所谓的变量可见性。

这个时候我们就知道,一个操作并不是只有一步,而中间的几步,如果其他的CPU修改了值,将会都产生覆盖,还是会出现不安全的情况,这就导致了 volatile 无法保证原子性。

以前的 ++ 操作示例,加上 synchronized 后结果就正确了,如果用 volatile 不用 synchronized呢?示例代码:

public class NoAtomic {
    private static volatile int num = 0;
    public static void main(String[] args) throws InterruptedException {
        for (int i=0; i<100; i++){
            new Thread(()->{
                for (int j=0; j < 100; j++){
                    num++;
                }
            }).start();
        }
    Thread.sleep(3000);
    System.out.println(num);
    }
}

可以发现,输出结果小于预期,虽然 volatile 保证了可见性,但是却不能保证操作的原子性。
因此想要保证原子性,还是得回去找 synchronized 或者使用原子类。

二、volatile 和 sync++hronized 的区别

  • volatile 本质是在告诉 jvm 当前变量在寄存器(工作内存)中的值是不确定的,需要从主存中读取;synchronized 则是锁定当前变量,只有当前线程可以访问该变量,其他线程被阻塞住。

  • volatile 仅能使用在变量级别;synchronized则可以使用在变量、方法、和类级别的。

  • volatile 仅能实现变量的修改可见性,不能保证原子性;而 synchronized 则可以保证变量的修改可见性和原子性。

  • volatile 不会造成线程的阻塞;synchronized 可能会造成线程的阻塞。

不过:现在基本不会用到 volatile,因为硬件层面,从工作内存到主存的更新速度已经提升的很快。


喜欢 (0)