并發編程中，我們可能會遇到這樣一個場景
A、B兩個執行緒并行，但是我希望保證B執行緒在A執行緒執行完了后再執行
這個時候就需要執行緒間進行通訊
A執行完了后對B說一聲，喂B，我執行完了
來康康用Java怎么實作
1、基于synchronized
2、基于reentrantLock
3、基于volatile
4、基于countDownLatch
我目前就知道這四種
1、synchronized+wait() 和 notify()
wait() 和 notify()都是Object類的通訊方法，注意一點，wait和 notify必須搭配synchronized使用，并且wait()會釋放鎖，notify()不會釋放鎖
public class SynchronizedTest {
//定義個year，用來記錄某明星的練習年數
private static double year;
public void run() {
//執行緒A，練習唱跳rap
Thread threadA = new Thread(() -> {
synchronized (this) {
for (year = 0.5; year <= 5; year += 0.5) {
System.out.println("蔡徐雞開始練習唱跳rap：已練習" + year + "年");
try {
Thread.sleep(288);
} catch (InterruptedException e) {
e.printStackTrace();
}
//眾所周知，練習兩年半即可出道
if (year == 2.5) {
System.out.println("===========================>成功練習兩年半，出道！！！");
this.notify();
}
}
}
});
//執行緒B，練習打籃球
Thread threadB = new Thread(() -> {
while (true) {
synchronized (this) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("蔡徐雞開始練習打籃球");
}
}
});
//注意，一定要先啟動B，不然會導致B永遠拿不到鎖
threadB.start();
threadA.start();
}
public static void main(String[] args) {
SynchronizedTest test = new SynchronizedTest();
test.run();
}
}
運行結果：
蔡徐雞開始練習唱跳rap：已練習0.5年
蔡徐雞開始練習唱跳rap：已練習1.0年
蔡徐雞開始練習唱跳rap：已練習1.5年
蔡徐雞開始練習唱跳rap：已練習2.0年
蔡徐雞開始練習唱跳rap：已練習2.5年
===========================>成功練習兩年半，出道！！！
蔡徐雞開始練習唱跳rap：已練習3.0年
蔡徐雞開始練習唱跳rap：已練習3.5年
蔡徐雞開始練習唱跳rap：已練習4.0年
蔡徐雞開始練習唱跳rap：已練習4.5年
蔡徐雞開始練習唱跳rap：已練習5.0年
蔡徐雞開始練習打籃球
注意看運行結果，執行緒A在執行notify后并沒有釋放鎖，而是執行完當前任務才開始執行執行緒B的任務
2、基于ReentrantLock
ReentrantLock也能實作執行緒間通訊，不過有點麻煩，需要結合ReentrantLock的Condition
public class LockTest {
//定義個year，用來記錄某明星練習打籃球的年數
private static double year;
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();
//執行緒A，練習唱跳rap
Thread threadA = new Thread(() -> {
//執行業務代碼前上鎖
lock.lock();
for (year = 0.5; year <= 5; year += 0.5) {
System.out.println("蔡徐雞開始練習唱跳rap：已練習" + year + "年");
try {
Thread.sleep(288);
} catch (InterruptedException e) {
e.printStackTrace();
}
//眾所周知，練習兩年半即可出道
if (year == 2.5) {
System.out.println("===========================>成功練習兩年半，出道！！！");
//喚醒等待中的執行緒
condition.signal();
}
}
//業務代碼執行完后解鎖
lock.unlock();
});
//執行緒B，練習打籃球
Thread threadB = new Thread(() -> {
//執行業務代碼前上鎖
lock.lock();
while (true) {
try {
//讓執行緒等待，如果計數器為0的話，則立即執行
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("蔡徐老母雞開始練習打籃球");
break;
}
//業務代碼執行完后解鎖
lock.unlock();
});
//注意，一定要先啟動B，不然會導致B永遠拿不到鎖
threadB.start();
threadA.start();
}
}
運行結果：
蔡徐雞開始練習唱跳rap：已練習0.5年
蔡徐雞開始練習唱跳rap：已練習1.0年
蔡徐雞開始練習唱跳rap：已練習1.5年
蔡徐雞開始練習唱跳rap：已練習2.0年
蔡徐雞開始練習唱跳rap：已練習2.5年
===========================>成功練習兩年半，出道！！！
蔡徐雞開始練習唱跳rap：已練習3.0年
蔡徐雞開始練習唱跳rap：已練習3.5年
蔡徐雞開始練習唱跳rap：已練習4.0年
蔡徐雞開始練習唱跳rap：已練習4.5年
蔡徐雞開始練習唱跳rap：已練習5.0年
蔡徐老母雞開始練習打籃球
效果和synchronized+wait() 和 notify()一樣一樣的
3、基于volatile
使用共享變數也能實作，用volatile即可，原理就是多個執行緒共同監聽同個變數，根據變數的值變化來執行對應的任務，此處volatile的作用就是讓其它執行緒能即時感知變數值的改變
public class volatileTest {
//定義一個共享變數，注意，必須用volatile修飾
static volatile boolean flag = false;
//定義個year，用來記錄某明星練習打籃球的年數
private static double year;
public static void main(String[] args) {
//執行緒A，練習唱跳rap
Thread threadA = new Thread(() -> {
while (true) {
if (!flag) {
for (year = 0.5; year <= 5; year += 0.5) {
System.out.println("蔡徐雞開始練習唱跳rap：已練習" + year + "年");
try {
Thread.sleep(288);
} catch (InterruptedException e) {
e.printStackTrace();
}
//眾所周知，練習兩年半即可出道
if (year == 2.5) {
System.out.println("===========================>成功練習兩年半，出道！！！");
year = 0.5;
flag = true;
break;
}
}
}
}
});
//執行緒B，練習打籃球
Thread threadB = new Thread(() -> {
while (true) {
if (flag) {
System.out.println("蔡徐老母雞開始練習打籃球");
break;
}
}
});
// 啟動執行緒
threadA.start();
threadB.start();
}
}
運行結果：
蔡徐雞開始練習唱跳rap：已練習0.5年
蔡徐雞開始練習唱跳rap：已練習1.0年
蔡徐雞開始練習唱跳rap：已練習1.5年
蔡徐雞開始練習唱跳rap：已練習2.0年
蔡徐雞開始練習唱跳rap：已練習2.5年
===========================>成功練習兩年半，出道！！！
蔡徐老母雞開始練習打籃球
基于CountDownLatch
CountDownLatch是JUC包下的一個并發編程工具，主要有兩個方法，countDown和await，CountDownLatch底層維護了一個計數器，在實體化的時候設定，當呼叫countDown方法時，計數器減一，如果計數器在減一前已經為0，那么什么都不會發生，如果減一后變成0，則喚醒所有等待的執行緒；await方法會使當前執行緒等待，直到計數器為0
public class CountDownLatchTest {
//定義個year，用來記錄某明星練習打籃球的年數
private static double year;
public static void main(String[] args) {
CountDownLatch latch = new CountDownLatch(1);
//執行緒A，練習唱跳rap
Thread threadA = new Thread(() -> {
for (year = 0.5; year <= 5; year += 0.5) {
System.out.println("蔡徐雞開始練習唱跳rap：已練習" + year + "年");
try {
Thread.sleep(288);
} catch (InterruptedException e) {
e.printStackTrace();
}
//眾所周知，練習兩年半即可出道
if (year == 2.5) {
System.out.println("===========================>成功練習兩年半，出道！！！");
//計數器減一
latch.countDown();
}
}
});
//執行緒B，練習打籃球
Thread threadB = new Thread(() -> {
while (true) {
try {
//讓執行緒等待，如果計數器為0的話，則立即執行
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("蔡徐老母雞開始練習打籃球");
break;
}
});
// 啟動執行緒
threadA.start();
threadB.start();
}
}
運行結果：
蔡徐雞開始練習唱跳rap：已練習0.5年
蔡徐雞開始練習唱跳rap：已練習1.0年
蔡徐雞開始練習唱跳rap：已練習1.5年
蔡徐雞開始練習唱跳rap：已練習2.0年
蔡徐雞開始練習唱跳rap：已練習2.5年
===========================>成功練習兩年半，出道！！！
蔡徐雞開始練習唱跳rap：已練習3.0年
蔡徐老母雞開始練習打籃球
蔡徐雞開始練習唱跳rap：已練習3.5年
蔡徐雞開始練習唱跳rap：已練習4.0年
蔡徐雞開始練習唱跳rap：已練習4.5年
蔡徐雞開始練習唱跳rap：已練習5.0年
如果你多運行幾次，你會發現執行緒B執行的時機是隨機的，但永遠在計數器為0后才開始執行，也就是說計數器為0后，執行緒A和執行緒B誰搶到鎖就誰執行
文中所有demo都是復制即可運行，大家還是要多動手，家里有條件的都用idea跑一跑，沒條件的可以用手抄
嚶~
ok我話說完
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/257058.html
標籤：其他