Java并发编程与多线程（二）

线程安全性：当多个线程访问某个类时，这个类始终都能表现出正确的行为，那么就称这个类时线程安全的。

无状态的Servlet：不包含任何域，也不包含任何对其他类中域的引用。计算过程中的临时状态仅存在于线程栈上的局部变量，并且只能由正在执行的线程访问。因为两个线程无共享状态，就好像它们都在访问不同的实例。

因此：无状态对象一定是线程安全的。而且大多数Servlet都是无状态的。只有当Servlet在处理请求时需要保存一些信息，线程安全才会成为一个问题。

无状态Servlet实例代码：(从请求中提取出数值，然后进行因数分解，然后将结果封装到该Servlet的响应中） 

public class StatelessFactorizer implements Servlet {  
    public void service(ServletRequest req, ServletResponse resp) {  
        BigInteger i = extractFromRequest(req);  
        BigInteger[] factors = factor(i);  
        encodeIntoResponse(resp, factors);  
    }  
}  

原子性：对于访问同一个状态的所有操作，这个操作必须是以原子执行的。（假定有两个操作A和B，如果从执行A的线程来看，当另一个线程执行B时，要么将B全部执行完，要么完全不执行B）。

在java.util.concurrent.atomic包中包含了一些原子变量类，用于实现在数值和对象引用上的原子状态转换。当在无状态的类中添加一个状态时，如果该状态完全由线程安全的对象来管理，那么这个类仍然是线程安全的。（统计所处理的请求数量）

public class CountingFactorizer implements Servlet {  
    private final AtomicLong count = new AtomicLong(0);  
  
    public long getCount() { return count.get(); }  
  
    public void service(ServletRequest req, ServletResponse resp) {  
        BigInteger i = extractFromRequest(req);  
        BigInteger[] factors = factor(i);  
        count.incrementAndGet();  
        encodeIntoResponse(resp, factors);  
    }  
}  

加锁机制：当在Servlet中添加一个状态变量时，可以通过线程安全的对象来管理Servlet的状态；但如果想在Servlet中添加更多的状态，我们需要通过加锁的方式来完成。

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

下面有一个线程安全，但是性能很差的例子：（当连续两个请求对相同的数值进行因数分解时，可以直接使用上一次的计算结果，需要保存两个状态：最近执行因数分解的数值；分解结果）

public class SynchronizedFactorizer implements Servlet {  
    @GuardedBy("this") private BigInteger lastNumber;  
    @GuardedBy("this") private BigInteger[] lastFactors;  
  
    public synchronized void service(ServletRequest req, ServletResponse resp) {  
        BigInteger i = extractFromRequest(req);  
        if(i.equals(lastNumber))  
            encodeIntResponse(resp, lastFactors);  
        else {  
            BigInteger[] factors = factor(i);  
            lastNumber = i;  
            lastFactors = factors;  
            encodeIntoResponse(resp, factors);  
        }  
    }     
}  

内置锁是可重入的。“重入”意味着获取锁的操作的粒度是"线程"而不是"调用"。

重入的一种实现方式是，为每个锁关联一个获取计数值和一个所有者线程。当计数值为0时，这个锁就被认为是没有被任何线程持有，当线程请求一个未被持有的锁时，计数值将被递增，当线程退出同步代码块时，计数值会递减，当计数值为0时，锁被释放。

当执行时间较长的计算或者可能无法快速完成的操作时，一定不要持有锁。（例如I/O操作）

下面是一个改进后的代码块。将Servlet代码修改为使用两个独立的同步代码块，每个同步代码块只包含一小段代码。

public class CachedFactorizer implements Servlet {
	@GuardedBy("this") private BigInteger lastNumber;
	@GuardedBy("this") private BigInteger[] lastfactors;
	@GuardedBy("this") private long hits;
	@GuardedBy("this") private long cacheHits;

	public synchronized long getHits() { return hits; }
	public synchronized double getCacheHitRadio() {
		return (double)cacheHits / (double)hits;
	}

	public void service(ServletRequest req, ServletResponse resp) {
		BigInteger i = extractFromRequest(req);
		BigInteger[] factors = null;
		synchronized(this) {
			++hits;
			if(i.equals(lastNumber)) {
				++cacheHits;
				factors = lastfactors.clone();
			}
		}
		if(factors == null) {
			factors = factor(i);
			synchronized(this) {
				lastNumber = i;
				lastfactors = factors.clone();
			}
		}
		encodeIntoResponse(resp, factors);
	}
}