《JAVA并发编程实战》示例程序第一、二章
第一章：简介
程序清单1-1非线程安全的数值序列生成器
import net.jcip.annotations.NotThreadSafe;
@NotThreadSafe
public class UnsafeSequence {
private int value;
/*返回一个唯一的数值*/
public int getValue() {
return value++; //三个操作：读取，加一，赋值。 多线程并发操作value可能导致步骤被打乱
}
}
程序清单1-2 线程安全的数值序列生成器
public class Sequence {
private int value;
/*返回一个唯一的数值*/
public synchronized int getValue() { //各个线程串行访问
return value++;
}
}
第二章：线程安全性
程序清单2-1 一个无状态的Servlet ,各个线程间没有共享状态
@ThreadSafe
public class StatelessFactorizer implements Servlet{
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
BigInteger i = extractFromRequest(req);
BigInteger[] factories = factor(i);
encodeIntoResponse(res,factories);
}
}
程序清单2-3 延迟初始化中的竞态条件（不要这么做）
@NotThreadSafe
public class LazyInitRace {
private ExpensiveObject instance = null; //竞态条件
public ExpensiveObject getInstance() {
if(instance == null)
instance = new ExpensiveObject();
return new ExpensiveObject();
}
}
class ExpensiveObject{}
程序清单2-4 使用AtomicLong类型的变量来统计已处理请求的数量
/*servlet的状态就是计数器count的状态，count是线程安全的，所以servlet是线程安全的*/ public class CountingFactorizer implements Servlet { private final AtomicLong count = new AtomicLong(0); //原子变量类，实现在数值和对象引用上的原子状态转换 public long getCount() { return count.get(); } public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { BigInteger i = extractFromReqest(req); BigInteger[] factors = factor(i); count.incrementAndGet(); encodeIntoResponse(res,factors); } }
程序清单2-5 该Servlet在没有足够原子性保证的情况下对其最近计算结果进行缓存（不要这么做）
/** * 因数分解： * 在数学中，因数分解，又称素因数分解，是把一个正整数写成几个约数的乘积。例如，给出45这个数，它可以分解成3×3×5，根据算术基本定理，这样的分解结果应该是独一无二的 * * * 希望提升Servlet性能，将最近的计算结果缓存起来，当2个连续的请求对相同的数值进行因数分解时，可以直接使用上一次的计算结果. * * 原子引用本身是线程安全的，但是业务逻辑中存在竞态条件 ： * lastFactors[0] * lastFactors[1] * ..... = lastNumber; 此条件不被破坏，Servlet才是线程安全的。 */ @NotThreadSafe public class UnsafeCachingFactorizer implements Servlet { //lastNumber、lastFactors本身是线程安全的 private final AtomicReference<BigInteger> lastNumber = new AtomicReference<BigInteger>(); //上一次请求的 因数 private final AtomicReference<BigInteger[]> lastFactors = new AtomicReference<BigInteger[]>(); //上一次请求的 因数分解结果 public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { BigInteger i = extractFromReqest(req); if(i.equals(lastNumber)){ encodeIntoResponse(res,lastFactors.get()); } else { BigInteger[] factors = factor(i); lastNumber.set(i); //无法保证同时与lastFactors更新， lastFactors.set(factors); //无法保证同时与lastNumber更新 encodeIntoResponse(res,factors); } } }
程序清单2-6 该Servlet能正确地缓存最新的最近计算结果，但并发性确非常糟糕（不要这么做）
@ThreadSafe public class SynchronizedFactorizer implements Servlet { @GuardedBy("this") private BigInteger lastNumber; //上一次请求的 因数 @GuardedBy("this") private BigInteger[] lastFactors; //上一次请求的 因数分解结果 public synchronized void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { BigInteger i = extractFromReqest(req); if(i.equals(lastNumber)){ encodeIntoResponse(res,lastFactors); } else { BigInteger[] factors = factor(i); lastNumber = i; lastFactors = factors; encodeIntoResponse(res,factors); } } }
程序清单2-7，如果内置所不可重置，那么以下代码将发生死锁
/** * 一线程请求其它线程持有的锁时，发出请求的线程将会被阻塞。 * 然而，内置锁是可重入的，某线程试图获得自己持有的锁时，这个请求将成功。 * “重入” 意味着获取锁的粒度是“线程”，而不是“调用” * * “重入”的实现：计数器。锁一次 +1，释放一次-1。 =0时锁被释放。 * @author guchunchao * */ public class Widget { public synchronized void widget() { //TODO ...... } } class LoggingWidget extends Widget { @Override public synchronized void widget() { // TODO ...... super.widget(); //如果内置锁不可重入，这里将无法获得Widget上的锁，因为这个锁已经被持有，而线程将永远停顿下去，等待一个永远也无法获得的锁。 } }
复合操作的原子性无法通过单个方法的synchronized保证
//Vector类的每一个方法都是synchronized，仅保证单个方法的原子性；当多个方法组合在一起的复合操作时，不足以保证复合操作的原子性，需要额外加锁 if(!vector.contains(name)) vector.add(name);
程序清单2-8 缓存最近执行因数分解的数值及其计算结果的Servlet
//注意：在单个变量上实现原子操作来说，原子变量（Atomic.....）是很有用的，不要把原子变量和同步代码块同时使用，这会带来混乱，也不会再性能或安全性上带来任何好处。
@ThreadSafe public class SynchronizedFactorizer { @GuardedBy("this") private BigInteger lastNumber; //上一次请求的 因数 @GuardedBy("this") private BigInteger[] lastFactors; //上一次请求的 因数分解结果 @GuardedBy("this") private long hits; //请求数量 @GuardedBy("this") private long cacheHist; //缓存命中数量 /**获取访Servlet调用问数量*/ public synchronized long getHits() {return this.hits;} /**获取缓存命中率*/ public synchronized double getHitsRatio() {return (double)cacheHist / (double)hits;} /**更细粒度的同步*/ public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { BigInteger i = extractFromReqest(req); //从页面获取待因数分解的数 BigInteger[] factors = null; synchronized(this) { ++hits; //同步竞态条件：请求数 和 缓存命中数 可能同步更改 if(i.equals(lastNumber)){ //命中缓存 ++cacheHist; //同步竞态条件：请求数 和 缓存命中数 可能同步更改 factors = lastFactors.clone(); } } if(factors == null){ //缓存未命中，与上次请求的数值不一样 factors = factor(i); //执行因数分解 synchronized(this) { lastNumber = i; //同步缓存竞态条件 lastNumber = lastFactors[0] * lastFactors[1] * ...... lastFactors = factors.clone(); //同步缓存竞态条件，用clone是因为factors是在同步代码块儿外定义的变量 } encodeIntoResponse(res,factors); } } }
