volatile的作用和基本使用

本文探讨了Java中volatile关键字的作用,包括确保线程间可见性和禁止指令重排序。虽然volatile能解决线程可见性问题,但它无法保证原子性。在并发场景下,volatile配合synchronize才能确保数据的正确性。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一、为什么改了值线程不可见?

上一节讲到了怎样创建一个线程,于是写出了一个多线程代码

public class HelloVolatile {
    boolean flag = true;
    void circle() {
        System.out.println("start");
        while(flag) {
        }
        System.out.println("end");
    }

    public static void main(String[] args) {
        HelloVolatile helloVolatile = new HelloVolatile();
        new Thread(helloVolatile::circle, "t1").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        helloVolatile.flag = false;
    }
}

运行结果如下:
运行结果
代码通过一个flag表示来控制循环是否停止,按我们理解主线程flag变为true之后,应该循环停止,会打印出end出来,可是事实没有打印?为什么?

二、线程可见性

通过查相关资料得知,线程为了提高处理速度,处理器不直接和内存进行通信,而是先将系统内存的数据读到内部缓存后再进行操作,但操作完不知道何时会写到内存。 所以需要一个新的技术实现线程可见性,随之引入了volatile,通过volatile修饰后的变量。可以理解成在变量上加了一个标识。通过这个标识我们可以实现:

  1. 保证修改的值会立即被更新到主存;
  2. 一个处理器的缓存回写到内存会导致其他处理器的缓存失效;
  3. 当处理器发现本地缓存失效后,就会从内存中重读该变量数据,即可以获取当前最新值;

代码修改后

public class HelloVolatile {
    volatile boolean flag = true;
    void circle() {
        System.out.println("start");
        while(flag) {
        }
        System.out.println("end");
    }

    public static void main(String[] args) {
        HelloVolatile helloVolatile = new HelloVolatile();
        new Thread(helloVolatile::circle, "t1").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        helloVolatile.flag = false;
    }
}

运行结果:
运行结果

三、禁止指令重排序

查阅了有关volatile相关信息,还有个作用:禁止指令重排序

public class LazySingleton {
    private volatile static LazySingleton instance = null;
    private LazySingleton() {
    }
    public static LazySingleton getInstance() {
        if(instant == null) {
            synchronized(LazySingleton.class) {
                if(instant == null) {
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }
}

instant = new LazySingleton()这个操作编译器编译后在指令分成三步:

  1. 申请内存
  2. 给成员变量初始化
  3. 把这块内存的内容赋值给instance

指令重排序和cpu有关,cpu为了加快运行速度,1、2、3三个步骤执行顺序有可能会重叠,并不一定步骤1执行完了,再执行步骤2,步骤2执行完了,再执行步骤3。
如图:
时序图

所以在极端情况下,步骤3将内存已经赋值给了instance,可是步骤2还没有完成。恰好另外一个线程进来发现instance==null且synchronized锁也释放了,则又 new LazySingleton()一次,导致的问题。
如果加上volitale后,则步骤1执行完了,再执行步骤2,步骤2执行完了,再执行步骤3来禁止指令重排序。但是在很极端的情况下才会发生,本机很难复测出这种情况,只需要记住这个概念,在高并发下记住有这个问题存在,记得使用volitale即可。

四、volitale无法保证原子性,需要借助synchronize保证原子性

学习了synchronize和volitale之后,忽然会觉得synchronize某种情况下岂不是无效,直接用volitale即可。如下:

public class VolatileNotHaveSync {
	volatile int count = 0;

	 void m() {
		for (int i = 0; i < 10000; i++)
			count++;
	}

	public static void main(String[] args) {
		VolatileNotHaveSync t = new VolatileNotHaveSync();

		List<Thread> threads = new ArrayList<Thread>();
		for (int i = 0; i < 10; i++) {
			threads.add(new Thread(t::m, "thread-" + i));
		}
		threads.forEach((o) -> o.start());
		threads.forEach((o) -> {
			try {
				o.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});

		System.out.println(t.count);

	}

}

执行结果:
执行结果
没有得到预期的结果100000,为什么呢?
其实很简单,volitale只能保证线程间的可见性,但是无法保证原子性,多个线程同时读取这个值时,进行count++,则会出现错误结果。
修改代码如下:

public class VolatileNotHaveSync {
	volatile int count = 0;

	 synchronized void m() {
		for (int i = 0; i < 10000; i++)
			count++;
	}

	public static void main(String[] args) {
		VolatileNotHaveSync t = new VolatileNotHaveSync();

		List<Thread> threads = new ArrayList<Thread>();
		for (int i = 0; i < 10; i++) {
			threads.add(new Thread(t::m, "thread-" + i));
		}
		threads.forEach((o) -> o.start());
		threads.forEach((o) -> {
			try {
				o.join();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		});

		System.out.println(t.count);

	}
}

运行结果如下:
运行结果
结果如预期一致。

### C++ 中 `volatile` 关键字的作用 `volatile` 关键字告知编译器对象的值可能在编译器无法检测的情况下发生变化,这意味着编译器不应对此变量应用某些类型的优化[^1]。 #### 使用场景 主要应用于以下几种情形: - **硬件寄存器**:这些寄存器的内容可由外部设备更改。 - **中断服务程序**:在此期间修改的全局变量应声明为 `volatile`。 - **多线程环境**:当多个线程共享同一变量并对其进行操作时,该变量应当标记为 `volatile` 以便每次访问都重新加载最新的内存值[^5]。 #### 正确用法 为了正确使用 `volatile`,需遵循特定的语法规则。具体而言,在定义变量时加上此关键字即可实现功能[^2]。 ```cpp // 定义一个带有 volatile 的整型数 volatile int variable; ``` 下面是一个具体的例子展示如何利用 `volatile` 来阻止不必要的编译器优化从而避免潜在的问题[^3]。 ```cpp #include <iostream> using namespace std; int main() { volatile int i = 10; // 输出初始值 cout << "Initial value of i: " << i << endl; // 修改内存地址处的实际数值 (模拟外部变化) __asm__ ("movl $80, %0" : "=m" (i)); // 再次打印以验证更新后的值已被获取 cout << "Updated value of i after modification: " << i << endl; } ``` 这段代码说明了即使是在汇编指令直接改变了存储位置上的原始数据之后,由于 `i` 被设定了 `volatile` 属性,所以后续对该变量的操作总是能够得到最新的实际值而不是缓存版本。 #### 类型安全性注意事项 值得注意的是,虽然简单基本类型可以直接有效地运用 `volatile` 进行保护,但是对于更复杂的结构体或类成员,则需要注意保持良好的类型兼容性一致性。如果尝试将非 `volatile` 对象赋给 `volatile` 变量将会引发编译错误,因为这样做违反了类型系统的预期[^4]。 ```cpp class Widget { public: int data; }; void example() { Widget regularWidget; volatile Widget volatileWidget; // 不应该初始化为 non-volatile 实例 // 下面这行会导致编译失败 // volatileWidget = regularWidget; } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值