1.死鎖
死鎖是這樣一種情形：多個線程同時被阻塞，它們中的一個或者全部都在等待某個資源被釋放。由于線程被無限期地阻塞，因此程序不可能正常終止。
Java 死鎖產(chǎn)生的四個必要條件：
1、互斥使用，即當資源被一個線程使用(占有)時，別的線程不能使用
2、不可搶占，資源請求者不能強制從資源占有者手中奪取資源，資源只能由資源占有者主動釋放。
3、請求和保持，即當資源請求者在請求其他的資源的同時保持對原有資源的占有。
4、循環(huán)等待，即存在一個等待隊列：P1占有P2的資源，P2占有P3的資源，P3占有P1的資源。這樣就形成了一個等待環(huán)路。
當上述四個條件都成立的時候，便形成死鎖。當然，死鎖的情況下如果打破上述任何一個條件，便可讓死鎖消失。
2.模擬一個死鎖
java" id="highlighter_613316">
|
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
package com.tl.skyLine.thread; import java.util.Date; /** * Created by tl on 17/3/3. */public class DeadLock { public static String bowl = "碗"; public static String chopsticks = "筷子"; public static void main(String[] args) { LockA la = new LockA(); new Thread(la).start(); LockB lb = new LockB(); new Thread(lb).start(); } } class LockA implements Runnable { public void run() { try { System.out.println(new Date().toString() + "鄒保健開始拿餐具吃飯"); while (true) { synchronized (DeadLock.bowl) { System.out.println(new Date().toString() + "鄒保健搶到了碗"); Thread.sleep(3000); // 此處等待是給B能鎖住機會 synchronized (DeadLock.chopsticks) { System.out.println(new Date().toString() + "鄒保健搶到了筷子"); Thread.sleep(60 * 1000); // 為測試，占用了就不放 } } } } catch (Exception e) { e.printStackTrace(); } } } class LockB implements Runnable { public void run() { try { System.out.println(new Date().toString() + "陳頂天開始拿餐具吃飯"); while (true) { synchronized (DeadLock.chopsticks) { System.out.println(new Date().toString() + "陳頂天搶到了筷子"); Thread.sleep(3000); // 此處等待是給A能鎖住機會 synchronized (DeadLock.bowl) { System.out.println(new Date().toString() + "陳頂天搶到了碗"); Thread.sleep(60 * 1000); // 為測試，占用了就不放 } } } } catch (Exception e) { e.printStackTrace(); } } } |
結果：
|
1
2
3
4
|
Fri Mar 03 16:34:36 CST 2017陳頂天開始拿餐具吃飯 Fri Mar 03 16:34:37 CST 2017陳頂天搶到了筷子 Fri Mar 03 16:34:36 CST 2017鄒保健開始拿餐具吃飯 Fri Mar 03 16:34:37 CST 2017鄒保健搶到了碗 |
結果陳頂天同學搶到了參筷子，拿著不放，鄒保健同學搶到了碗，也死活不放手，但是只有一雙筷子和一雙碗，結果就是雙雙餓死。。。
3.避免死鎖
假如我們是陳頂天和鄒保健同學的同事，肯定不忍心看到他們餓死，那么怎么辦呢？
我們就要采取方法避免思索的發(fā)生，這邊介紹兩種方法，一種是加鎖順序（線程按照一定的順序加鎖）；另一種是加鎖時限（線程嘗試獲取鎖的時候加上一定的時限，超過時限則放棄對該鎖的請求，并釋放自己占有的鎖）；
3.1 加鎖順序
當多個線程需要相同的一些鎖，但是按照不同的順序加鎖，死鎖就很容易發(fā)生。如果能確保所有的線程都是按照相同的順序獲得鎖，那么死鎖就不會發(fā)生。我們上面的代碼為了模擬死鎖，將線程LockA與LockB兩位同事的搶奪資源順序做了一個調(diào)整，LockA先搶碗，然后sleep3秒，LockB先搶筷子，我們現(xiàn)在把爭奪資源順序改一下，兩個線程都是先搶碗，再搶筷子，嚴格按照這個順序運行，那么A搶到碗以后，B去爭奪資源，必須從搶碗開始，不能在搶不到碗的情況下去搶筷子，這樣就避免死鎖的發(fā)生，這也是避免死鎖最簡單的方法。
代碼修改如下：
|
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
/** * Created by tl on 17/3/3. */public class UnDeadLock { public static String bowl = "碗"; public static String chopsticks = "筷子"; public static void main(String[] args) { LockA la = new LockA(); new Thread(la).start(); LockB lb = new LockB(); new Thread(lb).start(); } } class LockA implements Runnable { public void run() { try { System.out.println(new Date().toString() + "鄒保健開始拿餐具吃飯"); while (true) { synchronized (UnDeadLock.bowl) { System.out.println(new Date().toString() + "鄒保健搶到了碗"); synchronized (UnDeadLock.chopsticks) { System.out.println(new Date().toString() + "鄒保健搶到了筷子"); } } Thread.sleep(5000); } } catch (Exception e) { e.printStackTrace(); } } } class LockB implements Runnable { public void run() { try { System.out.println(new Date().toString() + "陳頂天開始拿餐具吃飯"); while (true) { synchronized (UnDeadLock.bowl) { System.out.println(new Date().toString() + "陳頂天搶到了碗"); synchronized (UnDeadLock.chopsticks) { System.out.println(new Date().toString() + "陳頂天搶到了筷子"); } } Thread.sleep(5000); } } catch (Exception e) { e.printStackTrace(); } } } |
此時運行結果
|
1
2
3
4
5
6
7
8
9
10
11
12
|
Fri Mar 24 11:16:51 CST 2017鄒保健開始拿餐具吃飯 Fri Mar 24 11:16:51 CST 2017陳頂天開始拿餐具吃飯 Fri Mar 24 11:16:51 CST 2017鄒保健搶到了碗 Fri Mar 24 11:16:51 CST 2017鄒保健搶到了筷子 Fri Mar 24 11:16:51 CST 2017陳頂天搶到了碗 Fri Mar 24 11:16:51 CST 2017陳頂天搶到了筷子 Fri Mar 24 11:16:56 CST 2017鄒保健搶到了碗 Fri Mar 24 11:16:56 CST 2017鄒保健搶到了筷子 Fri Mar 24 11:16:56 CST 2017陳頂天搶到了碗 Fri Mar 24 11:16:56 CST 2017陳頂天搶到了筷子 Fri Mar 24 11:17:01 CST 2017鄒保健搶到了碗 Fri Mar 24 11:17:01 CST 2017鄒保健搶到了筷子 |
就不會再出現(xiàn)死鎖的情況了。
3.2 加鎖時效
加鎖時效的原理就是：給每一個訪問線程增加訪問時效，若一個線程沒有在給定的時限內(nèi)成功獲得所有需要的鎖，則會進行回退并釋放所有已經(jīng)獲得的鎖（此時就打破了造成死鎖的四個原因中的第三個原因），然后等待一段隨機的時間再重試。
為了實現(xiàn)這個目標，我們不使用顯示的去鎖，我而是用信號量Semaphore去控制。信號量可以控制資源能被多少線程訪問，這里我們指定只能被一個線程訪問，就做到了類似鎖住。而信號量可以指定去獲取的超時時間，我們可以根據(jù)這個超時時間，去做一個額外處理。對于無法成功獲取的情況，一般就是重復嘗試，或指定嘗試的次數(shù)，也可以馬上退出。
|
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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
|
package com.tl.skyLine.thread; import java.util.Date; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; /** * Created by tl on 17/3/3. */public class UnDeadLock { public static String bowl = "碗"; //信號量可以碗只能能被一個線程同時訪問 public static final Semaphore a1 = new Semaphore(1); public static String chopsticks = "筷子"; //信號量可以筷子只能能被一個線程同時訪問 public static final Semaphore a2 = new Semaphore(1); public static void main(String[] args) { LockAa la = new LockAa(); new Thread(la).start(); LockBa lb = new LockBa(); new Thread(lb).start(); } } class LockAa implements Runnable { public void run() { try { System.out.println(new Date().toString() + "鄒保健開始拿餐具吃飯"); while (true) { if (UnDeadLock.a1.tryAcquire(1, TimeUnit.SECONDS)) { System.out.println(new Date().toString() + "鄒保健搶到了碗"); if (UnDeadLock.a2.tryAcquire(1, TimeUnit.SECONDS)) { System.out.println(new Date().toString() + "鄒保健搶到了筷子,湊齊了餐具,準備吃飯"); Thread.sleep(60 * 1000 * 10); // 搶到餐具就開始吃飯,吃飯時間十分鐘 } else { System.out.println(new Date().toString() + "筷子已經(jīng)被搶走了,鄒保健搶筷子失敗"); } } else { System.out.println(new Date().toString() + "碗已經(jīng)被搶走了,鄒保健搶碗失敗"); } UnDeadLock.a1.release(); // 釋放 UnDeadLock.a2.release(); System.out.println(new Date().toString() + "鄒保健把搶到的部分餐具又放回原處"); Thread.sleep(1000); // 馬上進行嘗試，現(xiàn)實情況下do something是不確定的 } } catch (Exception e) { e.printStackTrace(); } } } class LockBa implements Runnable { public void run() { try { System.out.println(new Date().toString() + "陳頂天開始拿餐具吃飯"); while (true) { if (UnDeadLock.a2.tryAcquire(1, TimeUnit.SECONDS)) { System.out.println(new Date().toString() + "陳頂天搶到了筷子"); if (UnDeadLock.a1.tryAcquire(1, TimeUnit.SECONDS)) { System.out.println(new Date().toString() + "陳頂天搶到了碗,湊齊了餐具,準備吃飯"); Thread.sleep(60 * 1000 * 10); // 搶到餐具就開始吃飯,吃飯時間十分鐘 } else { System.out.println(new Date().toString() + "碗已經(jīng)被搶走了,陳頂天搶碗失敗"); } } else { System.out.println(new Date().toString() + "筷子已經(jīng)被搶走了,陳頂天搶筷子失敗"); } UnDeadLock.a1.release(); // 釋放 UnDeadLock.a2.release(); System.out.println(new Date().toString() + "陳頂天把搶到的部分餐具又放回原處"); Thread.sleep(10 * 1000);//這里只是為了演示，所以tryAcquire只用1秒，而且B要給A讓出能執(zhí)行的時間，否則兩個永遠是死鎖 } } catch (Exception e) { e.printStackTrace(); } } } |
結果
|
1
2
3
4
5
6
7
8
9
10
11
|
Fri Mar 03 18:12:07 CST 2017鄒保健開始拿餐具吃飯 Fri Mar 03 18:12:07 CST 2017陳頂天開始拿餐具吃飯 Fri Mar 03 18:12:07 CST 2017鄒保健搶到了碗 Fri Mar 03 18:12:07 CST 2017陳頂天搶到了筷子 Fri Mar 03 18:12:08 CST 2017筷子已經(jīng)被搶走了,鄒保健搶筷子失敗 Fri Mar 03 18:12:08 CST 2017鄒保健把搶到的部分餐具又放回原處 Fri Mar 03 18:12:08 CST 2017陳頂天搶到了碗,湊齊了餐具,準備吃飯 Fri Mar 03 18:12:10 CST 2017碗已經(jīng)被搶走了,鄒保健搶碗失敗 Fri Mar 03 18:12:10 CST 2017鄒保健把搶到的部分餐具又放回原處 Fri Mar 03 18:12:11 CST 2017鄒保健搶到了碗 Fri Mar 03 18:12:11 CST 2017鄒保健搶到了筷子,湊齊了餐具,準備吃飯 |
很明顯看到，我們打破了滿足死鎖的第三條，即當資源請求者在請求其他的資源的同時保持對原有資源的占有，當沒有完全搶到碗和筷子的時候，兩個人（線程）全部釋放占有的資源，重新開始爭搶資源，這樣一個人搶到碗和筷子之后，吃飽再給另一個吃，這樣你就成功了拯救了你的兩位同事！
Semaphore api：
|
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
|
acquire public void acquire() throws InterruptedException 從此信號量獲取一個許可，在提供一個許可前一直將線程阻塞，否則線程被中斷。獲取一個許可（如果提供了一個）并立即返回，將可用的許可數(shù)減 1。 如果沒有可用的許可，則在發(fā)生以下兩種情況之一前，禁止將當前線程用于線程安排目的并使其處于休眠狀態(tài)： 某些其他線程調(diào)用此信號量的 release() 方法，并且當前線程是下一個要被分配許可的線程；或者 其他某些線程中斷當前線程。 如果當前線程： 被此方法將其已中斷狀態(tài)設置為 on ；或者 在等待許可時被中斷。 則拋出 InterruptedException，并且清除當前線程的已中斷狀態(tài)。 拋出： InterruptedException - 如果當前線程被中斷 release public void release() 釋放一個許可，將其返回給信號量。釋放一個許可，將可用的許可數(shù)增加 1。如果任意線程試圖獲取許可，則選中一個線程并將剛剛釋放的許可給予它。然后針對線程安排目的啟用（或再啟用）該線程。 不要求釋放許可的線程必須通過調(diào)用 acquire() 來獲取許可。通過應用程序中的編程約定來建立信號量的正確用法。 |
wait()與sleep()的區(qū)別：
sleep()方法只讓出了CPU，而并不會釋放同步資源鎖！！！
wait()方法則是指當前線程讓自己暫時退讓出同步資源鎖，以便其他正在等待該資源的線程得到該資源進而運行;
以上這篇java多線程學習之死鎖的模擬和避免(實例講解)就是小編分享給大家的全部內(nèi)容了，希望能給大家一個參考，也希望大家多多支持服務器之家。
