一、同步問題提出
線程的同步是為了防止多個線程訪問一個數據對象時，對數據造成的破壞。
例如：兩個線程ThreadA、ThreadB都操作同一個對象Foo對象，并修改Foo對象上的數據。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
package cn.thread;public class Foo { private int x = 100; public int getX() { return x; } public int fix(int y) { x = x - y; return x; }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
package cn.thread;public class MyRunnable implements Runnable { private Foo foo = new Foo(); public static void main(String[] args) { MyRunnable run = new MyRunnable(); Thread ta = new Thread(run, "Thread-A"); Thread tb = new Thread(run, "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-B : 當前foo對象的x值= 40
Thread-A : 當前foo對象的x值= 40
Thread-B : 當前foo對象的x值= -20
Thread-A : 當前foo對象的x值= -20
Thread-B : 當前foo對象的x值= -80
Thread-A : 當前foo對象的x值= -80
從結果發現，這樣的輸出值明顯是不合理的。原因是兩個線程不加控制的訪問Foo對象并修改其數據所致。
如果要保持結果的合理性，只需要達到一個目的，就是將對Foo的訪問加以限制，每次只能有一個線程在訪問。這樣就能保證Foo對象中數據的合理性了。
在具體的Java代碼中需要完成一下兩個操作：
把競爭訪問的資源類Foo變量x標識為private；
同步哪些修改變量的代碼，使用synchronized關鍵字同步方法或代碼。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
package cn.thread;public class Foo2 { private int x = 100; public int getX() { return x; } //同步方法 public synchronized int fix(int y) { x = x - y; System.out.println("線程"+Thread.currentThread().getName() + "運行結束，減少“" + y + "”，當前值為：" + x); return x; } // //同步代碼塊// public int fix(int y) {// synchronized (this) {// x = x - y;// System.out.println("線程"+Thread.currentThread().getName() + "運行結束，減少“" + y// + "”，當前值為：" + x);// }// // return x;// }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
package cn.thread;public class MyRunnable2 { public static void main(String[] args) { MyRunnable2 run = new MyRunnable2(); Foo2 foo2=new Foo2(); MyThread t1 = run.new MyThread("線程A", foo2, 10); MyThread t2 = run.new MyThread("線程B", foo2, -2); MyThread t3 = run.new MyThread("線程C", foo2, -3); MyThread t4 = run.new MyThread("線程D", foo2, 5); t1.start(); t2.start(); t3.start(); t4.start(); } class MyThread extends Thread { private Foo2 foo2; /**當前值*/ private int y = 0; MyThread(String name, Foo2 foo2, int y) { super(name); this.foo2 = foo2; this.y = y; } public void run() { foo2.fix(y); } }} |
線程線程A運行結束，減少“10”，當前值為：90
線程線程C運行結束，減少“-3”，當前值為：93
線程線程B運行結束，減少“-2”，當前值為：95
線程線程D運行結束，減少“5”，當前值為：90
二、同步和鎖定
1、鎖的原理
Java中每個對象都有一個內置鎖。
當程序運行到非靜態的synchronized同步方法上時，自動獲得與正在執行代碼類的當前實例（this實例）有關的鎖。獲得一個對象的鎖也稱為獲取鎖、鎖定對象、在對象上鎖定或在對象上同步。
當程序運行到synchronized同步方法或代碼塊時該對象鎖才起作用。
一個對象只有一個鎖。所以，如果一個線程獲得該鎖，就沒有其他線程可以獲得鎖，直到第一個線程釋放（或返回）鎖。這也意味著任何其他線程都不能進入該對象上的synchronized方法或代碼塊，直到該鎖被釋放。
釋放鎖是指持鎖線程退出了synchronized同步方法或代碼塊。
關于鎖和同步，有一下幾個要點：
1）、只能同步方法，而不能同步變量和類；
2）、每個對象只有一個鎖；當提到同步時，應該清楚在什么上同步？也就是說，在哪個對象上同步？
3）、不必同步類中所有的方法，類可以同時擁有同步和非同步方法。
4）、如果兩個線程要執行一個類中的synchronized方法，并且兩個線程使用相同的實例來調用方法，那么一次只能有一個線程能夠執行方法，另一個需要等待，直到鎖被釋放。也就是說：如果一個線程在對象上獲得一個鎖，就沒有任何其他線程可以進入（該對象的）類中的任何一個同步方法。
5）、如果線程擁有同步和非同步方法，則非同步方法可以被多個線程自由訪問而不受鎖的限制。
6）、線程睡眠時，它所持的任何鎖都不會釋放。
7）、線程可以獲得多個鎖。比如，在一個對象的同步方法里面調用另外一個對象的同步方法，則獲取了兩個對象的同步鎖。
8）、同步損害并發性，應該盡可能縮小同步范圍。同步不但可以同步整個方法，還可以同步方法中一部分代碼塊。
9）、在使用同步代碼塊時候，應該指定在哪個對象上同步，也就是說要獲取哪個對象的鎖。例如：
|
1
2
3
4
5
6
|
public int fix(int y) { synchronized (this) { x = x - y; } return x;} |
當然，同步方法也可以改寫為非同步方法，但功能完全一樣的，例如：
|
1
2
3
|
public synchronized int getX() { return x++;} |
與
|
1
2
3
4
5
|
public int getX() { synchronized (this) { return x++; }} |
效果是完全一樣的。
三、靜態方法同步
要同步靜態方法，需要一個用于整個類對象的鎖，這個對象就是這個類（XXX.class)。
例如：
|
1
2
3
|
public static synchronized int setName(String name){ Xxx.name = name;} |
等價于
|
1
2
3
4
5
|
public static int setName(String name){ synchronized(Xxx.class){ Xxx.name = name; }} |
四、如果線程不能獲得鎖會怎么樣
如果線程試圖進入同步方法，而其鎖已經被占用，則線程在該對象上被阻塞。實質上，線程進入該對象的的一種池中，必須在哪里等待，直到其鎖被釋放，該線程再次變為可運行或運行為止。
當考慮阻塞時，一定要注意哪個對象正被用于鎖定：
1、調用同一個對象中非靜態同步方法的線程將彼此阻塞。如果是不同對象，則每個線程有自己的對象的鎖，線程間彼此互不干預。
2、調用同一個類中的靜態同步方法的線程將彼此阻塞，它們都是鎖定在相同的Class對象上。
3、靜態同步方法和非靜態同步方法將永遠不會彼此阻塞，因為靜態方法鎖定在Class對象上，非靜態方法鎖定在該類的對象上。
4、對于同步代碼塊，要看清楚什么對象已經用于鎖定（synchronized后面括號的內容）。在同一個對象上進行同步的線程將彼此阻塞，在不同對象上鎖定的線程將永遠不會彼此阻塞。
五、何時需要同步
在多個線程同時訪問互斥（可交換）數據時，應該同步以保護數據，確保兩個線程不會同時修改更改它。
對于非靜態字段中可更改的數據，通常使用非靜態方法訪問。
對于靜態字段中可更改的數據，通常使用靜態方法訪問。
如果需要在非靜態方法中使用靜態字段，或者在靜態字段中調用非靜態方法，問題將變得非常復雜。已經超出SJCP考試范圍了。
六、線程安全類
當一個類已經很好的同步以保護它的數據時，這個類就稱為“線程安全的”。
即使是線程安全類，也應該特別小心，因為操作的線程是間仍然不一定安全。
七、線程同步小結
1、線程同步的目的是為了保護多個線程訪問一個資源時對資源的破壞。
2、線程同步方法是通過鎖來實現，每個對象都有切僅有一個鎖，這個鎖與一個特定的對象關聯，線程一旦獲取了對象鎖，其他訪問該對象的線程就無法再訪問該對象的其他同步方法。
3、對于靜態同步方法，鎖是針對這個類的，鎖對象是該類的Class對象。靜態和非靜態方法的鎖互不干預。一個線程獲得鎖，當在一個同步方法中訪問另外對象上的同步方法時，會獲取這兩個對象鎖。
4、對于同步，要時刻清醒在哪個對象上同步，這是關鍵。
5、編寫線程安全的類，需要時刻注意對多個線程競爭訪問資源的邏輯和安全做出正確的判斷，對“原子”操作做出分析，并保證原子操作期間別的線程無法訪問競爭資源。
6、當多個線程等待一個對象鎖時，沒有獲取到鎖的線程將發生阻塞。
7、死鎖是線程間相互等待鎖鎖造成的，在實際中發生的概率非常的小。真讓你寫個死鎖程序，不一定好使，呵呵。但是，一旦程序發生死鎖，程序將死掉。
原文鏈接：http://www.cnblogs.com/linjiqin/p/3208843.html
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持服務器之家。
