volatile线程不安全例子

volatile并不能保证在运算时多线程安全,例如下面的例子


public class VolatileTest {
	public static volatile int race = 0;
	public static  void increase(){
		race++;
	}
	
	private static final int THREADS_COUNT = 20;
	
	public static void main(String[] args){
		Thread[] threads = new Thread[ THREADS_COUNT ];
		for(int i=0; i<THREADS_COUNT; i++){
			threads[i] = new Thread(new Runnable() {
				@Override
				public void run() {
					for(int j=0; j<10000; j++)
						increase();
				}
			});
			
			threads[i].start();
		}
	
		while(Thread.activeCount() > 1){
			Thread.yield();
		}
		System.out.println(race);
	}
}

期待的结果是2000,结果却不是,小于2000.

在increase方法假设synchronized关键字之后就变成了2000。

下面来看下increase方法的字节码 (这个字节码只是说明 ++操作的步骤,和volatile关键字无关)

 public static void increase();
   Code:
      0: getstatic     #14                 // Field race:I
      3: iconst_1
      4: iadd
      5: putstatic     #14                 // Field race:I
      8: return

getstatic 获取指定类的静态域,并将其值压入栈顶

iconst_1 int型常量值1进栈

iadd 栈顶两int型数值相加,并且结果进栈

putstatic 为指定的类的静态域赋值


由于中间需要多个步骤,任意时刻都可能有其它线程切入。

getstatic 时,volatile保证了race的值在此时是正确的,但是在执行 iconst-1 和 iadd 时,其它线程可能已经把race的值加大了。而在操作栈顶的值就变成了过期的数据。



<think>好的,我现在需要回答用户关于“Volatile关键字能不能保证线程安全”的问题。首先,我得回忆一下volatile关键字在Java中的作用。记得volatile主要保证变量的可见性和禁止指令重排序,但保证原子性。线程安全需要这三个方面都得到保障吗? 接下来,我应该分步骤解释。先说明volatile的作用,然后讨论线程安全的三个要素:原子性、可见性、有序性。再分析volatile如何影响这些方面。可能需要举例子,比如自增操作是原子的,即使变量是volatile,多线程下仍会出问题。 然后,我应该对比volatile和synchronized的区别,或者用原子类比如AtomicInteger来展示如何确保原子性。同时,要提到volatile适用的场景,比如状态标志位,或者双重检查锁定模式中的单实现,说明在这些情况下volatile如何保证安全。 还要注意用户可能存在的误解,认为volatile能解决所有线程问题,需要明确纠正这一点。结构上,先结论,再逐步展开,用例子说明,最后总结适用场景和限制。需要确保用中文,术语准确,例子清晰。检查是否有错误,比如指令重排序部分是否正确,以及可见性的解释是否到位。可能还要提到内存屏障的概念,但用太深入。总之,要让用户明白volatile的作用范围,以及线程安全需要的其他条件。</think>Volatile关键字**不能完全保证线程安全**,但它能在特定场景下辅助实现线程安全。以下是逐步分析: --- ### 一、Volatile的核心作用 1. **可见性保证** 当一个变量被声明为`volatile`时,所有线程都能看到该变量的最新值。 - **普通变量**:线程可能从本地缓存中读取旧值。 - **Volatile变量**:直接读取主内存中的最新值。 - 示: ```java volatile boolean flag = false; // 线程A修改flag=true后,线程B能立即看到新值 ``` 2. **禁止指令重排序** Volatile通过插入**内存屏障**(Memory Barrier)禁止编译器和CPU对指令的优化重排,确保代码执行顺序符合预期。 --- ### 二、Volatile的局限性(无法保证线程安全的原因) 1. **保证原子性** **原子性**指一个操作可被中断。如`i++`实际包含`读取→修改→写入`三个步骤,即使`i`是volatile的,多线程并发时仍可能发生数据竞争。 - 示: ```java volatile int count = 0; // 线程A和B同时执行count++,最终结果可能小于预期 ``` 2. **适用场景有限** Volatile仅适用于以下两种场景: - **状态标志位**:单个线程修改,其他线程读取。 ```java volatile boolean isShutdown = false; // 线程A设置isShutdown=true,线程B检测到后终止 ``` - **双重检查锁定(Double-Checked Locking)**: ```java class Singleton { private static volatile Singleton instance; public static Singleton getInstance() { if (instance == null) { // 第一次检查 synchronized (Singleton.class) { if (instance == null) { // 第二次检查 instance = new Singleton(); // volatile禁止new操作的指令重排序 } } } return instance; } } ``` --- ### 三、线程安全的完整条件 线程安全需满足以下三个特性: 1. **原子性**:通过`synchronized`或`AtomicXXX`类(如`AtomicInteger`)实现。 2. **可见性**:通过`volatile`或`synchronized`实现。 3. **有序性**:通过`volatile`或`synchronized`实现。 --- ### 四、总结 - **能依赖Volatile的场景**:单一变量的写操作依赖当前值(如状态标志位)。 - **不能依赖Volatile的场景**:复合操作(如`i++`)、多变量协作。 - **替代方案**: - 使用`synchronized`保证原子性。 - 使用`java.util.concurrent.atomic`包下的原子类(如`AtomicInteger`)。 - 使用锁(如`ReentrantLock`)。 ```java // 正确示:使用AtomicInteger保证原子性 AtomicInteger atomicCount = new AtomicInteger(0); atomicCount.incrementAndGet(); // 线程安全的自增 ```
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值