一、同步問題提出
線程的同步是為了防止多個線程訪問一個數據對象時，對數據造成的破壞。
例如：兩個線程ThreadA、ThreadB都操作同一個對象Foo對象，並修改Foo對 象上的數據。
public class Foo {
private int x = 100;
public int getX() {
return x;
}
public int fix(int y) {
x = x - y;
return x;
}
}
public class MyRunnable implements Runnable {
private Foo foo = new Foo();
public static void main(String[] args) {
MyRunnable r = new MyRunnable();
Thread ta = new Thread(r, "Thread-A");
Thread tb = new Thread(r, "Thread-B");
ta.start();
tb.start();
}
public void run() {
for (int i = 0; i < 3; i++) {
this.fix(30);
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread ().getName() + " : 當前foo對象的x值= " + foo.getX());
}
}
public int fix(int y) {
return foo.fix(y);
}
}
運行結果：Thread-A : 當前foo對象的x值= 40
Thread-B : 當前foo對象的x值= 40
Thread-B : 當前foo對象的x值= -20
Thread-A : 當前foo對象的x值= -50
Thread-A : 當前foo對象的x值= -80
Thread-B : 當前foo對象的x值= -80
Process finished with exit code 0
從結果發現，這樣的輸出值明顯是不合理的。原因是兩個線程不加控制的訪 問Foo對象並修改其數據所致。
如果要保持結果的合理性，只需要達到一個目的，就是將對Foo的訪問加以限 制，每次只能有一個線程在訪問。這樣就能保證Foo對象中數據的合理性了。
在具體的Java代碼中需要完成一下兩個操作：
把競爭訪問的資源類Foo變量x標識為private；
同步哪些修改變量的代碼，使用synchronized關鍵字同步方法或代碼。
二、同步和鎖定
1、鎖的原理
Java中每個對象都有一個內置鎖
當程序運行到非靜態的synchronized同步方法上時，自動獲得與正在執行代 碼類的當前實例（this實例）有關的鎖。獲得一個對象的鎖也稱為獲取鎖、鎖定 對象、在對象上鎖定或在對象上同步。
當程序運行到synchronized同步方法或代碼塊時才該對象鎖才起作用。
一個對象只有一個鎖。所以，如果一個線程獲得該鎖，就沒有其他線程可以 獲得鎖，直到第一個線程釋放（或返回）鎖。這也意味著任何其他線程都不能進 入該對象上的synchronized方法或代碼塊，直到該鎖被釋放。
釋放鎖是指持鎖線程退出了synchronized同步方法或代碼塊。
關於鎖和同步，有一下幾個要點：
1）、只能同步方法，而不能同步變量和類；
2）、每個對象只有一個鎖；當提到同步時，應該清楚在什麼上同步？也就是 說，在哪個對象上同步？
3）、不必同步類中所有的方法，類可以同時擁有同步和非同步方法。
4）、如果兩個線程要執行一個類中的synchronized方法，並且兩個線程使用 相同的實例來調用方法，那麼一次只能有一個線程能夠執行方法，另一個需要等 待，直到鎖被釋放。也就是說：如果一個線程在對象上獲得一個鎖，就沒有任何 其他線程可以進入（該對象的）類中的任何一個同步方法。
5）、如果線程擁有同步和非同步方法，則非同步方法可以被多個線程自由訪 問而不受鎖的限制。
6）、線程睡眠時，它所持的任何鎖都不會釋放。
7）、線程可以獲得多個鎖。比如，在一個對象的同步方法裡面調用另外一個 對象的同步方法，則獲取了兩個對象的同步鎖。
8）、同步損害並發性，應該盡可能縮小同步范圍。同步不但可以同步整個方 法，還可以同步方法中一部分代碼塊。
9）、在使用同步代碼塊時候，應該指定在哪個對象上同步，也就是說要獲取 哪個對象的鎖。例如：
public int fix(int y) {
synchronized (this) {
x = x - y;
}
return x;
}
當然，同步方法也可以改寫為非同步方法，但功能完全一樣的，例如：
public synchronized int getX() {
return x++;
}
與
public int getX() {
synchronized (this) {
return x;
}
}
效果是完全一樣的。
三、靜態方法同步
要同步靜態方法，需要一個用於整個類對象的鎖，這個對象是就是這個類 （XXX.class)。
例如：
public static synchronized int setName(String name){
Xxx.name = name;
}
等價於
public static int setName(String name){
synchronized(Xxx.class){
Xxx.name = name;
}
}
四、如果線程不能不能獲得鎖會怎麼樣
如果線程試圖進入同步方法，而其鎖已經被占用，則線程在該對象上被阻塞 。實質上，線程進入該對象的的一種池中，必須在哪裡等待，直到其鎖被釋放， 該線程再次變為可運行或運行為止。
當考慮阻塞時，一定要注意哪個對象正被用於鎖定：
1、調用同一個對象中非靜態同步方法的線程將彼此阻塞。如果是不同對象， 則每個線程有自己的對象的鎖，線程間彼此互不干預。
2、調用同一個類中的靜態同步方法的線程將彼此阻塞，它們都是鎖定在相同 的Class對象上。
3、靜態同步方法和非靜態同步方法將永遠不會彼此阻塞，因為靜態方法鎖定 在Class對象上，非靜態方法鎖定在該類的對象上。
4、對於同步代碼塊，要看清楚什麼對象已經用於鎖定（synchronized後面括 號的內容）。在同一個對象上進行同步的線程將彼此阻塞，在不同對象上鎖定的 線程將永遠不會彼此阻塞。
五、何時需要同步
在多個線程同時訪問互斥（可交換）數據時，應該同步以保護數據，確保兩 個線程不會同時修改更改它。
對於非靜態字段中可更改的數據，通常使用非靜態方法訪問。
對於靜態字段中可更改的數據，通常使用靜態方法訪問。
如果需要在非靜態方法中使用靜態字段，或者在靜態字段中調用非靜態方法 ，問題將變得非常復雜。已經超出SJCP考試范圍了。
六、線程安全類
當一個類已經很好的同步以保護它的數據時，這個類就稱為“線程安全的” 。
即使是線程安全類，也應該特別小心，因為操作的線程是間仍然不一定安全 。
舉個形象的例子，比如一個集合是線程安全的，有兩個線程在操作同一個集 合對象，當第一個線程查詢集合非空後，刪除集合中所有元素的時候。第二個線 程也來執行與第一個線程相同的操作，也許在第一個線程查詢後，第二個線程也 查詢出集合非空，但是當第一個執行清除後，第二個再執行刪除顯然是不對的， 因為此時集合已經為空了。
看個代碼：
public class NameList {
private List nameList = Collections.synchronizedList(new LinkedList());
public void add(String name) {
nameList.add(name);
}
public String removeFirst() {
if (nameList.size() > 0) {
return (String) nameList.remove(0);
} else {
return null;
}
}
}
public class Test {
public static void main(String[] args) {
final NameList nl = new NameList();
nl.add("aaa");
class NameDropper extends Thread{
public void run(){
String name = nl.removeFirst();
System.out.println(name);
}
}
Thread t1 = new NameDropper();
Thread t2 = new NameDropper();
t1.start();
t2.start();
}
}
雖然集合對象
private List nameList = Collections.synchronizedList(new LinkedList());
是同步的，但是程序還不是線程安全的。
出現這種事件的原因是，上例中一個線程操作列表過程中無法阻止另外一個 線程對列表的其他操作。
解決上面問題的辦法是，在操作集合對象的NameList上面做一個同步。改寫 後的代碼如下：
public class NameList {
private List nameList = Collections.synchronizedList(new LinkedList());
public synchronized void add(String name) {
nameList.add(name);
}
public synchronized String removeFirst() {
if (nameList.size() > 0) {
return (String) nameList.remove(0);
} else {
return null;
}
}
}
這樣，當一個線程訪問其中一個同步方法時，其他線程只有等待。
七、線程死鎖
死鎖對Java程序來說，是很復雜的，也很難發現問題。當兩個線程被阻塞， 每個線程在等待另一個線程時就發生死鎖。
還是看一個比較直觀的死鎖例子：
public class DeadlockRisk {
private static class Resource {
public int value;
}
private Resource resourceA = new Resource();
private Resource resourceB = new Resource();
public int read() {
synchronized (resourceA) {
synchronized (resourceB) {
return resourceB.value + resourceA.value;
}
}
}
public void write(int a, int b) {
synchronized (resourceB) {
synchronized (resourceA) {
resourceA.value = a;
resourceB.value = b;
}
}
}
}
假設read()方法由一個線程啟動，write()方法由另外一個線程啟動。讀線程 將擁有resourceA鎖，寫線程將擁有resourceB鎖，兩者都堅持等待的話就出現死 鎖。
實際上，上面這個例子發生死鎖的概率很小。因為在代碼內的某個點，CPU必 須從讀線程切換到寫線程，所以，死鎖基本上不能發生。
但是，無論代碼中發生死鎖的概率有多小，一旦發生死鎖，程序就死掉。有 一些設計方法能幫助避免死鎖，包括始終按照預定義的順序獲取鎖這一策略。已 經超出SCJP的考試范圍。
八、線程同步小結
1、線程同步的目的是為了保護多個線程反問一個資源時對資源的破壞。
2、線程同步方法是通過鎖來實現，每個對象都有切僅有一個鎖，這個鎖與一 個特定的對象關聯，線程一旦獲取了對象鎖，其他訪問該對象的線程就無法再訪 問該對象的其他非同步方法。
3、對於靜態同步方法，鎖是針對這個類的，鎖對象是該類的Class對象。靜 態和非靜態方法的鎖互不干預。一個線程獲得鎖，當在一個同步方法中訪問另外 對象上的同步方法時，會獲取這兩個對象鎖。
4、對於同步，要時刻清醒在哪個對象上同步，這是關鍵。
5、編寫線程安全的類，需要時刻注意對多個線程競爭訪問資源的邏輯和安全 做出正確的判斷，對“原子”操作做出分析，並保證原子操作期間別的線程無法 訪問競爭資源。
6、當多個線程等待一個對象鎖時，沒有獲取到鎖的線程將發生阻塞。
7、死鎖是線程間相互等待鎖鎖造成的，在實際中發生的概率非常的小。真讓 你寫個死鎖程序，不一定好使，呵呵。但是，一旦程序發生死鎖，程序將死掉。
