參考https://blog.csdn.net/xiaokang123456kao/article/details/77331878
一、題目描述
建立三個線程A、B、C，A線程打印10次字母A，B線程打印10次字母B,C線程打印10次字母C，但是要求三個線程同時運行，並且實現交替打印，即按照ABCABCABC的順序打印。
二、Synchronized同步法
1、基本思路
使用同步塊和wait、notify的方法控制三個線程的執行次序。具體方法如下：從大的方向上來講，該問題為三線程間的同步喚醒操作，主要的目的就是ThreadA->ThreadB->ThreadC->ThreadA循環執行三個線程。為了控制線程執行的順序，那么就必須要確定喚醒、等待的順序，所以每一個線程必須同時持有兩個對象鎖，才能進行打印操作。一個對象鎖是prev，就是前一個線程所對應的對象鎖，其主要作用是保證當前線程一定是在前一個線程操作完成后（即前一個線程釋放了其對應的對象鎖）才開始執行。還有一個鎖就是自身對象鎖。主要的思想就是，為了控制執行的順序，必須要先持有prev鎖（也就前一個線程要釋放其自身對象鎖），然后當前線程再申請自己對象鎖，兩者兼備時打印。之后首先調用self.notify()喚醒下一個等待線程（注意notify不會立即釋放對象鎖，只有等到同步塊代碼執行完畢后才會釋放），再調用prev.wait()立即釋放prev對象鎖，當前線程進入休眠，等待其他線程的notify操作再次喚醒。
2、代碼
經博友：璐璐的寶寶的指點，原程序雖然也能完成任務，但是存在一個很大的缺陷。為了對比一下，這里保留原實現，並給出新的改進實現。
原實現：
public class ABC_Synch {
public static class ThreadPrinter implements Runnable {
private String name;
private Object prev;
private Object self;
private ThreadPrinter(String name, Object prev, Object self) {
this.name = name;
this.prev = prev;
this.self = self;
}
@Override
public void run() {
int count = 10;
while (count > 0) {// 多線程並發，不能用if，必須使用whil循環
synchronized (prev) { // 先獲取 prev 鎖
synchronized (self) {// 再獲取 self 鎖
System.out.print(name);//打印
count--;
self.notifyAll();// 喚醒其他線程競爭self鎖，注意此時self鎖並未立即釋放。
}
//此時執行完self的同步塊，這時self鎖才釋放。
try {
prev.wait(); // 立即釋放 prev鎖，當前線程休眠，等待喚醒
/**
* JVM會在wait()對象鎖的線程中隨機選取一線程，賦予其對象鎖，喚醒線程，繼續執行。
*/
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public static void main(String[] args) throws Exception {
Object a = new Object();
Object b = new Object();
Object c = new Object();
ThreadPrinter pa = new ThreadPrinter("A", c, a);
ThreadPrinter pb = new ThreadPrinter("B", a, b);
ThreadPrinter pc = new ThreadPrinter("C", b, c);
new Thread(pa).start();
Thread.sleep(10);//保證初始ABC的啟動順序
new Thread(pb).start();
Thread.sleep(10);
new Thread(pc).start();
Thread.sleep(10);
}
}
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
運行結果：
可以看到程序一共定義了a,b,c三個對象鎖，分別對應A、B、C三個線程。A線程最先運行，A線程按順序申請c,a對象鎖，打印操作后按順序釋放a,c對象鎖，並且通過notify操作喚醒線程B。線程B首先等待獲取A鎖，再申請B鎖，后打印B，再釋放B，A鎖，喚醒C。線程C等待B鎖，再申請C鎖，后打印C，再釋放C,B鎖，喚醒A。看起來似乎沒什么問題，但如果你仔細想一下，就會發現有問題，就是初始條件，三個線程必須按照A,B,C的順序來啟動，但是這種假設依賴於JVM中線程調度、執行的順序。
原實現存在的問題：
如果把上述代碼放到eclipse上運行，可以發現程序雖然完成了交替打印ABC十次的任務，但是打印完畢后無法自動結束線程。這是為什么呢？原因就在於下面這段代碼：
try {
prev.wait(); // 立即釋放 prev鎖，當前線程休眠，等待喚醒
/**
* JVM會在wait()對象鎖的線程中隨機選取一線程，賦予其對象鎖，喚醒線程，繼續執行。
*/
} catch (InterruptedException e) {
e.printStackTrace();
}
1
2
3
4
5
6
7
8
prev.wait(); 是釋放prev鎖並休眠線程，等待喚醒。在最后一次打印完畢后，因為count為0，無法進入while循環的同步代碼塊，自然就不會觸發notifyAll操作。這樣一來，執行完打印操作后，線程就一直處於休眠待喚醒狀態，導致線程無法正常結束。
改進實現：
我們找到了了問題的原因，解決起來就簡單了。最直接的思路就是在最后一次打印操作時在不休眠線程的情況下釋放對象鎖，這可以通過notifyAll操作實現。於是改進的代碼如下：
public class ABC_Synch {
public static class ThreadPrinter implements Runnable {
private String name;
private Object prev;
private Object self;
private ThreadPrinter(String name, Object prev, Object self) {
this.name = name;
this.prev = prev;
this.self = self;
}
@Override
public void run() {
int count = 10;
while (count > 0) {// 多線程並發，不能用if，必須使用whil循環
synchronized (prev) { // 先獲取 prev 鎖
synchronized (self) {// 再獲取 self 鎖
System.out.print(name);// 打印
count--;
self.notifyAll();// 喚醒其他線程競爭self鎖，注意此時self鎖並未立即釋放。
}
// 此時執行完self的同步塊，這時self鎖才釋放。
try {
if (count == 0) {// 如果count==0,表示這是最后一次打印操作，通過notifyAll操作釋放對象鎖。
prev.notifyAll();
} else {
prev.wait(); // 立即釋放 prev鎖，當前線程休眠，等待喚醒
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public static void main(String[] args) throws Exception {
Object a = new Object();
Object b = new Object();
Object c = new Object();
ThreadPrinter pa = new ThreadPrinter("A", c, a);
ThreadPrinter pb = new ThreadPrinter("B", a, b);
ThreadPrinter pc = new ThreadPrinter("C", b, c);
new Thread(pa).start();
Thread.sleep(10);// 保證初始ABC的啟動順序
new Thread(pb).start();
Thread.sleep(10);
new Thread(pc).start();
Thread.sleep(10);
}
}
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
上述代碼放到eclipse上運行，就可以自動結束線程了。從這里，我們也可以得出wait和notify操作的異同：
wait() 與 notify/notifyAll() 是Object類的方法，在執行兩個方法時，要先獲得鎖。
當線程執行wait()時，會把當前的鎖釋放，然后讓出CPU，進入等待狀態。
當執行notify/notifyAll方法時，會喚醒一個處於等待該 對象鎖 的線程，然后繼續往下執行，直到執行完退出對象鎖鎖住的區域（synchronized修飾的代碼塊）后再釋放鎖。
從這里可以看出，notify/notifyAll()執行后，並不立即釋放鎖，而是要等到執行完臨界區中代碼后，再釋放。所以在實際編程中，我們應該盡量在線程調用notify/notifyAll()后，立即退出臨界區。即不要在notify/notifyAll()后面再寫一些耗時的代碼。
二、Lock鎖方法
1、基本思路
通過ReentrantLock我們可以很方便的進行顯式的鎖操作，即獲取鎖和釋放鎖，對於同一個對象鎖而言，統一時刻只可能有一個線程拿到了這個鎖，此時其他線程通過lock.lock()來獲取對象鎖時都會被阻塞，直到這個線程通過lock.unlock()操作釋放這個鎖后，其他線程才能拿到這個鎖。
2、代碼
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ABC_Lock {
private static Lock lock = new ReentrantLock();// 通過JDK5中的Lock鎖來保證線程的訪問的互斥
private static int state = 0;//通過state的值來確定是否打印
static class ThreadA extends Thread {
@Override
public void run() {
for (int i = 0; i < 10;) {
try {
lock.lock();
while (state % 3 == 0) {// 多線程並發，不能用if，必須用循環測試等待條件，避免虛假喚醒
System.out.print("A");
state++;
i++;
}
} finally {
lock.unlock();// unlock()操作必須放在finally塊中
}
}
}
}
static class ThreadB extends Thread {
@Override
public void run() {
for (int i = 0; i < 10;) {
try {
lock.lock();
while (state % 3 == 1) {// 多線程並發，不能用if，必須用循環測試等待條件，避免虛假喚醒
System.out.print("B");
state++;
i++;
}
} finally {
lock.unlock();// unlock()操作必須放在finally塊中
}
}
}
}
static class ThreadC extends Thread {
@Override
public void run() {
for (int i = 0; i < 10;) {
try {
lock.lock();
while (state % 3 == 2) {// 多線程並發，不能用if，必須用循環測試等待條件，避免虛假喚醒
System.out.print("C");
state++;
i++;
}
} finally {
lock.unlock();// unlock()操作必須放在finally塊中
}
}
}
}
public static void main(String[] args) {
new ThreadA().start();
new ThreadB().start();
new ThreadC().start();
}
}
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
運行結果
值得注意的是ReentrantLock是可重入鎖，它持有一個鎖計數器，當已持有鎖的線程再次獲得該鎖時計數器值加1，每調用一次lock.unlock()時所計數器值減一，直到所計數器值為0，此時線程釋放鎖。示例如下：
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockTest {
private ReentrantLock lock = new ReentrantLock();
public void testReentrantLock() {
// 線程獲得鎖
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + " get lock");
long beginTime = System.currentTimeMillis();
while (System.currentTimeMillis() - beginTime < 100) {
}
//線程再次獲得該鎖（可重入）
lock.lock();
try {
System.out.println(Thread.currentThread().getName() + " get lock again");
long beginTime2 = System.currentTimeMillis();
while (System.currentTimeMillis() - beginTime2 < 100) {
}
} finally {
// 線程第一次釋放鎖
lock.unlock();
System.out.println(Thread.currentThread().getName() + " release lock");
}
} finally {
// 線程再次釋放鎖
lock.unlock();
System.out.println(Thread.currentThread().getName() + " release lock again");
}
}
public static void main(String[] args) {
final ReentrantLockTest test = new ReentrantLockTest();
Thread thread = new Thread(new Runnable() {
public void run() {
test.testReentrantLock();
}
}, "A");
thread.start();
}
}
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
三、ReentrantLock結合Condition
1、基本思路
與ReentrantLock搭配的通行方式是Condition，如下：
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
condition.await();//this.wait();
condition.signal();//this.notify();
condition.signalAll();//this.notifyAll();
1
2
3
4
5
Condition是被綁定到Lock上的，必須使用lock.newCondition()才能創建一個Condition。從上面的代碼可以看出，Synchronized能實現的通信方式，Condition都可以實現，功能類似的代碼寫在同一行中。這樣解題思路就和第一種方法基本一致，只是采用的方法不同。
2、代碼
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ABC_Condition {
private static Lock lock = new ReentrantLock();
private static Condition A = lock.newCondition();
private static Condition B = lock.newCondition();
private static Condition C = lock.newCondition();
private static int count = 0;
static class ThreadA extends Thread {
@Override
public void run() {
try {
lock.lock();
for (int i = 0; i < 10; i++) {
while (count % 3 != 0)//注意這里是不等於0，也就是說在count % 3為0之前，當前線程一直阻塞狀態
A.await(); // A釋放lock鎖
System.out.print("A");
count++;
B.signal(); // A執行完喚醒B線程
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
static class ThreadB extends Thread {
@Override
public void run() {
try {
lock.lock();
for (int i = 0; i < 10; i++) {
while (count % 3 != 1)
B.await();// B釋放lock鎖，當前面A線程執行后會通過B.signal()喚醒該線程
System.out.print("B");
count++;
C.signal();// B執行完喚醒C線程
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
static class ThreadC extends Thread {
@Override
public void run() {
try {
lock.lock();
for (int i = 0; i < 10; i++) {
while (count % 3 != 2)
C.await();// C釋放lock鎖
System.out.print("C");
count++;
A.signal();// C執行完喚醒A線程
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) throws InterruptedException {
new ThreadA().start();
new ThreadB().start();
new ThreadC().start();
}
}
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
四、Semaphore信號量方式
1、基本思路
Semaphore又稱信號量，是操作系統中的一個概念，在Java並發編程中，信號量控制的是線程並發的數量。
public Semaphore(int permits)
1
其中參數permits就是允許同時運行的線程數目;
Semaphore是用來保護一個或者多個共享資源的訪問，Semaphore內部維護了一個計數器，其值為可以訪問的共享資源的個數。一個線程要訪問共享資源，先獲得信號量，如果信號量的計數器值大於1，意味着有共享資源可以訪問，則使其計數器值減去1，再訪問共享資源。如果計數器值為0,線程進入休眠。當某個線程使用完共享資源后，釋放信號量，並將信號量內部的計數器加1，之前進入休眠的線程將被喚醒並再次試圖獲得信號量。
Semaphore使用時需要先構建一個參數來指定共享資源的數量，Semaphore構造完成后即是獲取Semaphore、共享資源使用完畢后釋放Semaphore。
Semaphore semaphore = new Semaphore(10,true);
semaphore.acquire();
//do something here
semaphore.release();
1
2
3
4
2、代碼
import java.util.concurrent.Semaphore;
public class ABC_Semaphore {
// 以A開始的信號量,初始信號量數量為1
private static Semaphore A = new Semaphore(1);
// B、C信號量,A完成后開始,初始信號數量為0
private static Semaphore B = new Semaphore(0);
private static Semaphore C = new Semaphore(0);
static class ThreadA extends Thread {
@Override
public void run() {
try {
for (int i = 0; i < 10; i++) {
A.acquire();// A獲取信號執行,A信號量減1,當A為0時將無法繼續獲得該信號量
System.out.print("A");
B.release();// B釋放信號，B信號量加1（初始為0），此時可以獲取B信號量
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
static class ThreadB extends Thread {
@Override
public void run() {
try {
for (int i = 0; i < 10; i++) {
B.acquire();
System.out.print("B");
C.release();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
static class ThreadC extends Thread {
@Override
public void run() {
try {
for (int i = 0; i < 10; i++) {
C.acquire();
System.out.println("C");
A.release();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
new ThreadA().start();
new ThreadB().start();
new ThreadC().start();
}
}
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
執行結果：
可以看到信號量的變化情況如下：
初始(A=1,B=0,C=0)—>第一次執行線程A時(A=1,B=0,C=0)—->第一次執行線程B時（A=0,B=1,C=0）—->第一次執行線程C時(A=0,B=0,C=1)—>第二次執行線程A(A=1,B=0,C=0)如此循環。
————————————————
版權聲明：本文為CSDN博主「想作會飛的魚」的原創文章，遵循CC 4.0 by-sa版權協議，轉載請附上原文出處鏈接及本聲明。
原文鏈接：https://blog.csdn.net/xiaokang123456kao/article/details/77331878