竞态条件的赋值_竞态条件 - chen2013 - 博客园

在并发编程中，这种由于不恰当的执行时序而出现不正确的结果是一种非常严重的情况，它有一个正式的名字叫做：竞态条件

使用“先检查后执行”的一种常见情况就是延迟初始化。延迟初始化的目的是将对象的初始化操作推迟到实际被使用时才进行，同时要确保只被初始化一次。

@NotThreadSafepublic classLazyInitRace {private ExpensiveObject instance = null;publicExpensiveObject getInstance() {if (instance == null)

instance= newExpensiveObject();returninstance;

}

}class ExpensiveObject { }

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

为了确保线程安全性，"先检查后执行"(例如延迟初始化)和"读取-修改-写入" 等操作必须是原子的。

@ThreadSafepublic class CountingFactorizer extends GenericServlet implementsServlet {private final AtomicLong count = new AtomicLong(0);public long getCount() { returncount.get(); }public voidservice(ServletRequest req, ServletResponse resp) {

BigInteger i=extractFromRequest(req);

BigInteger[] factors=factor(i);

count.incrementAndGet();

encodeIntoResponse(resp, factors);

}voidencodeIntoResponse(ServletResponse res, BigInteger[] factors) {}

BigInteger extractFromRequest(ServletRequest req) {return null; }

BigInteger[] factor(BigInteger i) {return null; }

}

上述代码是线程安全的，因为使用了AtomicLong类型确保数值和对象引用上的原子状态转换是安全的。因为这里的计数是安全的，所以这里的Servlet也是线程安全的。

@NotThreadSafepublic class UnsafeCachingFactorizer extends GenericServlet implementsServlet {private final AtomicReferencelastNumber= new AtomicReference();private final AtomicReferencelastFactors= new AtomicReference();public voidservice(ServletRequest req, ServletResponse resp) {

BigInteger i=extractFromRequest(req);if(i.equals(lastNumber.get()))

encodeIntoResponse(resp, lastFactors.get());else{

BigInteger[] factors=factor(i);

lastNumber.set(i);

lastFactors.set(factors);

encodeIntoResponse(resp, factors);

}

}voidencodeIntoResponse(ServletResponse resp, BigInteger[] factors) {

}

BigInteger extractFromRequest(ServletRequest req) {return new BigInteger("7");

}

BigInteger[] factor(BigInteger i) {//Doesn't really factor

return newBigInteger[]{i};

}

}

上述代码看似使用了AtomicReference，对于这些对象是原子性的，但是不能确保这两个变量的组合是原子性的，也可能出现两个对象存在数量不同的情况。

Java提供了一种内置的锁机制来支持原子性：同步代码块(Synchronized Block)

synchronized 关键字，代表这个方法加锁,相当于不管哪一个线程A每次运行到这个方法时,都要检查有没有其它正在用这个方法的线程B(或者C D等),有的话要等正在使用这个方法的线程B(或者C D)运行完这个方法后再运行此线程A,没有的话,直接运行它包括两种用法：synchronized 方法和 synchronized 块。

@ThreadSafepublic class SynchronizedFactorizer extends GenericServlet implementsServlet {

@GuardedBy("this") privateBigInteger lastNumber;

@GuardedBy("this") privateBigInteger[] lastFactors;public synchronized voidservice(ServletRequest req,

ServletResponse resp) {

BigInteger i=extractFromRequest(req);if(i.equals(lastNumber))

encodeIntoResponse(resp, lastFactors);else{

BigInteger[] factors=factor(i);

lastNumber=i;

lastFactors=factors;

encodeIntoResponse(resp, factors);

}

}voidencodeIntoResponse(ServletResponse resp, BigInteger[] factors) {

}

BigInteger extractFromRequest(ServletRequest req) {return new BigInteger("7");

}

BigInteger[] factor(BigInteger i) {//Doesn't really factor

return newBigInteger[] { i };

}

}

这种同步机制使得要确保因数分解的Servlet的线程安全性变得更简单。用了关键字synchronized来修饰service方法，因此在同一时刻只有一个线程可以执行service方法。现在的SynchronizedFactorizer是线程安全的。然而，这种方法却过于极端，因为多个客户端无法同时使用因数分解Servlet，服务的响应性非常低，无法令人接受。这是一个性能问题，而不是线程安全问题。