java多线程：Volatile关键字&&DCL单例模式，volatile 和 synchronized 的区别

快来打我* 2022-12-03 15:51 125阅读 0赞

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-Checked-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 和 synchronized 的区别 #

*  volatile 本质是在告诉 jvm 当前变量在寄存器（工作内存）中的值是不确定的，需要从主存中读取；synchronized 则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
 *  volatile 仅能使用在变量级别；synchronized则可以使用在变量、方法、和类级别的。
 *  volatile 仅能实现变量的修改可见性，不能保证原子性；而 synchronized 则可以保证变量的**修改可见性和原子性。**
 *  volatile 不会造成线程的阻塞；synchronized 可能会造成线程的阻塞。

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