線程安全篇B
為了保持狀態的一致性，需要在一個原子性操作中更新相關的狀態變量，加鎖，可以將一些混合操作變為原子性操作，從而保證線程安全。
鎖
- 內部鎖
Java提供了一個加強原子性的內在鎖機理-同步塊，其包含兩部分，一部分是一個可以作為鎖的對象的引用，另一部分是由這個鎖保護的阻塞代碼。同步方法是同步塊的一個快捷體現，其作用于所有的方法體。
每一個Java對象都可以作為一個潛在的同步鎖，這種內部構建的鎖叫做內部鎖或是管程鎖。當線程進入同步塊前會自動獲得鎖，并在執行退出(正常或異常的情況)后，自動釋放鎖。
內在鎖是一種互斥鎖，即至多有一個線程可以擁有鎖。當線程A想要獲得線程B獲得的鎖，它必須等待或者阻塞，直到B線程釋放鎖，若不釋放，A會一直等待。
- 重入性
重入性指的是鎖的獲得基于每個線程，而不是基于每次調用；一個線程可以成功請求獲得它已經持有的鎖；
該特性的實現是因為鎖的請求獲得次數（lockcount）和持有它的線程的關聯來實現的。當一個線程獲得或者再次獲得鎖時，在虛擬機里將會lockcount+1，當一個同步塊退出時，虛擬機會讓lockcount-1。當lockcount=0時，該線程釋放鎖。
重入性簡化了面向對象的并發操作，否則的話，像如下代碼中，將會發生死鎖。
public class Widget {
public synchronized void doSomething() {
...
}
}
public class LoggingWidget extends Widget {
public synchronized void doSomething() {
System.out.println(toString() + ": calling doSomething");
super.doSomething();
}
}
用鎖保護狀態
由于鎖可以將對代碼的訪問變得序列化，因此可以使用鎖來構建一些策略來保障共享狀態的排他性。
一個可以被多個線程訪問的可變狀態，所有的訪問都需要持有共同的鎖，此時，我們稱這個狀態被這個鎖保護。
對象的內部鎖和它的狀態沒有內在的關聯，一個對象的成員不會自動被其內部鎖保護。獲得一個對象的內部鎖，僅僅會阻止其它線程獲得這個鎖，但并不妨礙其它線程訪問這個對象。
每次共享時，一個可變狀態需要指定一個具體的鎖，并使其使用者知道是哪個鎖。
對于每一個擁有多于一個變量的不變量來說，它的所有變量應該使用同一個鎖來保護。
一個通用的鎖策略是，將所有可變狀態用一個對象封裝起來，然后所有訪問這些可變狀態的代碼都用這個對象的內部鎖保護起來，用來防止并發訪問。這種方式很常用，也很簡單，但是這樣會導致活性和性能問題。
活性和性能
不合適的同步，特別是同步耗時操作，會使得并發能力下降，甚至失去并發能力。
用兩段代碼解釋更直觀。
- 粗糙同步,省略了一些次要代碼。Servlet框架的設計本意是同時處理多個請求，但是同步后的service方法一旦有耗時操作，那么由于同步的原因，其它的請求只能等上一個請求完成之后才能進行，降低了處理性能。
public class SynchronizedFactorizer extends GenericServlet 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))
encodeIntoResponse(resp, lastFactors);
else {
BigInteger[] factors = factor(i);
lastNumber = i;
lastFactors = factors;
encodeIntoResponse(resp, factors);
}
}
void encodeIntoResponse(ServletResponse resp, BigInteger[] factors) {
}
BigInteger extractFromRequest(ServletRequest req) {
return new BigInteger("7");
}
BigInteger[] factor(BigInteger i) {
// Doesn't really factor
return new BigInteger[] { i };
}
}
- 精細同步，只需進行精致的分割，改變同步的位置，便能盡可能的消除加鎖對性能帶來的影響。見代碼：
public class CachedFactorizer extends GenericServlet 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 getCacheHitRatio() {
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);
}
void encodeIntoResponse(ServletResponse resp, BigInteger[] factors) {
}
BigInteger extractFromRequest(ServletRequest req) {
return new BigInteger("7");
}
BigInteger[] factor(BigInteger i) {
// Doesn't really factor
return new BigInteger[]{i};
}
}
如何確定同步塊的大小需要考慮安全性，易用性和性能。有時候，易用性和性能是一對相對矛盾的設計指標。無論何時在使用鎖時，應該考慮到被同步的代碼能做什么，以及這些代碼耗時大概多少。進行大量的計算或是存在潛在的阻塞操作，都有可能加長持有鎖的時間，進一步影響到程序的活性和性能。
涉及大量計算和耗時操作（如net或者io）的代碼，應避免持有鎖。
//待下篇
