java 并发 竞态条件（1）

竞态条件，说得通俗一点，就是线程A 需要判断一个变量的状态，然后根据这个变量的状态来执行某个操作。

在执行这个操作之前，这个变量的状态可能会被其他线程修改。

看一个例子

Java代码  

1. import java.util.concurrent.atomic.AtomicLong;  
2.   
3.   
4. public class LazyInitRace {  
5.     private ExpensiveObject instance=null;  
6.       
7.     public ExpensiveObject getInstance(){  
8.         if(instance==null){  
9.             instance=new ExpensiveObject();  
10.         }  
11.         return instance;  
12.     }  
13. }  

 在LazyInitRace 中包含了一个竞态条件，它可能会破坏这个类的正确性。假定线程A和线程B 同时执行getInstance 方法。A 看到instance 为空，因此A创建一个新的ExpensiveObject实例。B 同样需要判断instance 是否为空。此时的instance是否为空，要取决于不可预测的时序，包括线程的调度方式，以及A 需要花多长时间来初始化ExpensiveObject并设置instance。如果当B检查时，instance为空，那么在两次调用getInstance 时可能会得到不同的对象。

线程A和B的执行时序可能是这样的：

 说明：线程B 在执行红色部分代码（判断instance是否为空）时，线程A 还没来得执行完绿色部分的代码。

也可能是这样的：

 

有什么解决方案呢？

方案一：内置锁

每个Java对象都可以用作一个实现同步的锁。

线程进入内置锁保护的代码块时就拥有锁，执行完这段代码块时就自动释放锁。同一时刻只能有一个线程拥有锁，其他的线程只能等待。也就是说，当线程A 进入内置锁保护的代码块时，其他线程是不能执行这段代码的，只能等待线程A执行完毕。

线程安全的代码如下：

Java代码  

1. public class LazyInitRace {  
2.     private ExpensiveObject instance=null;  
3.       
4.     public synchronized ExpensiveObject getInstance(){  
5.         if(instance==null){  
6.             instance=new ExpensiveObject();  
7.         }  
8.         return instance;  
9.     }  
10. }