7月8日

以下文章來源于編程新說?，作者編程新說李新杰

多線程的問題都曾經困擾過每個開發人員，今天將從全新視角來解說，希望讀者都能明白。

強烈建議去運行下文章中的示例代碼，自己體會下。

問題究竟出在哪里？

一個線程執行，固然是安全的，但是有時太慢了，怎么辦？

老祖宗告訴我們，“一方有難，八方支援”，那不就是多叫幾個線程來幫忙嘛，好辦呀，多new幾個不就行了，又不要錢。這樣能管用嗎？繼續往下看。

俗話說，“在家靠父母，出門靠朋友”。有了朋友的幫助，就會事半功倍。是這樣的嗎？

不一定，如果朋友“不靠譜”，結果竟是在“添亂”。于是就演變為，“不怕神一樣的對手，就怕豬一樣的隊友”。可見“人多力量大”縱然是對的，但也要配合好才能成事。

人和人是朋友，那線程和線程也是“朋友”，如果多線程之間不能配合好的話，最終也會變為“豬一樣的隊友”。事實證明，這也不是一件易事。且容我慢慢道來。

開發是一門技術，管理是一門藝術。也許你正想帶著兄弟們大干一場，可偏偏就有人要辭職。或者你付出了這么多，但別人從來沒有感動過。為什么會這樣呢？

因為你面對的是人。每個人都是獨立的個體，有思想，有靈魂，有情感，有三觀。能夠接受外界的“輸入”，經過“處理”后，能夠產生“輸出”。

說白了就是會自主的分析問題，并做出決定。這叫什么呢？答案就是，主觀能動性。

擁有主觀能動性的物體（比如人），你需要和它協商著或配合著來共同完成一件事情，而不能“強迫”它去做什么，因為這樣往往不會有好的結果。

費了這么多口舌，就是希望把問題盡量的簡單化。終于可以回到程序了，那線程的情況是不是類似的呢？答案是肯定的。

一個線程準備好后，經過CPU的調度，就可以自主的運行了。此時它儼然成了一個獨立的個體，且具有主觀能動性。

這本是一件好事，但卻也有不好的一面，那就是你對它的“掌控”能力變弱了，頗有一種“將在外，君命有所不受”的感覺。

可能你不同意這種看法，說我可以“強迫”它停止運行，調用Thread類的stop()方法來直接把它“掐死”，不好意思，該方法已廢棄。

因為線程可能在運行一些“關鍵”代碼（比如轉賬），此刻不能被終止。Thread類還有一些其它的方法也都廢棄了，大抵原因其實都差不多。

講了這么多，相信你已經明白了，簡單總結一下：

事情起因：線程可以獨立自主的運行，可以認為它具有主觀能動性。

造成結果：對它的掌控能力變弱了，而且又不能直接把它“干掉”。

解決方案：凡事商量著來，互相配合著把事情完成。

作者觀點：其實就是把線程當作人來對待。

小試牛刀一下

一旦把線程當成人，就來到了人類的世界，這我們太熟悉了，所以很多問題都會變得非常簡單明了。一起來看看吧。


場景一，停止

“大胖，大胖，12點了，該去吃飯了，別寫了”

“好的，好的，稍等片刻，把這幾行代碼寫完就走”

要點：把停止的信號傳達給別人，別人處理完手頭的事情就自己主動停止了。
?

static void stopByFlag() {ARunnable ar = new ARunnable();new Thread(ar).start();ar.tellToStop();}static class ARunnable implements Runnable {volatile boolean stop;void tellToStop() {stop = true;}@Overridepublic void run() {println("進入不可停止區域 1。。。");doingLongTime(5);println("退出不可停止區域 1。。。");println("檢測標志stop = %s", String.valueOf(stop));if (stop) {println("停止執行");return;}println("進入不可停止區域 2。。。");doingLongTime(5);println("退出不可停止區域 2。。。");}}

解說：線程在預設的地點檢測flag，來決定是否停止。

場景二，暫停/恢復

“大胖，大胖，先別發請求了，對方服務器快掛了”

“好的，好的，等這個執行完就不發了”

過了一會

“大胖，大胖，可以重新發請求了”

“好的，好的”

要點：把暫停的信號傳達給別人，別人處理完手頭的事情就自己主動暫停了。但是恢復是無法自主進行的，只能由操作系統來恢復線程的執行。

static void pauseByFlag() {BRunnable br = new BRunnable();new Thread(br).start();br.tellToPause();sleep(8);br.tellToResume();}static class BRunnable implements Runnable {volatile boolean pause;void tellToPause() {pause = true;}void tellToResume() {synchronized (this) {this.notify();}}@Overridepublic void run() {println("進入不可暫停區域 1。。。");doingLongTime(5);println("退出不可暫停區域 1。。。");println("檢測標志pause = %s", String.valueOf(pause));if (pause) {println("暫停執行");try {synchronized (this) {this.wait();}} catch (InterruptedException e) {e.printStackTrace();}println("恢復執行");}println("進入不可暫停區域 2。。。");doingLongTime(5);println("退出不可暫停區域 2。。。");}}

解說：還是在預設的地點檢測flag。然后就是wait/notify配合使用。

場景三，插隊

“大胖，大胖，讓我站到你前面，不想排隊了”

“好吧”

要點：別人插隊到你前面，必須等他完事后才輪到你。

static void jqByJoin() {CRunnable cr = new CRunnable();Thread t = new Thread(cr);t.start();sleep(1);try {t.join();} catch (InterruptedException e) {e.printStackTrace();}println("終于輪到我了");}static class CRunnable implements Runnable {@Overridepublic void run() {println("進入不可暫停區域 1。。。");doingLongTime(5);println("退出不可暫停區域 1。。。");}}

解說：join方法可以讓某個線程插到自己前面，等它執行完，自己才會繼續執行。

?

場景四，叫醒

“大胖，大胖，醒醒，醒醒，看誰來了”

“誰啊，我去”

要點：要把別人從睡夢中叫醒，一定要采取稍微暴力一點的手段。
?

static void stopByInterrupt() {DRunnable dr = new DRunnable();Thread t = new Thread(dr);t.start();sleep(2);t.interrupt();}static class DRunnable implements Runnable {@Overridepublic void run() {println("進入暫停。。。");try {sleep2(5);} catch (InterruptedException e) {println("收到中斷異常。。。");println("做一些相關處理。。。");}println("繼續執行或選擇退出。。。");}}

解說：線程在sleep或wait時，是處于無法交互的狀態的，此時只能使用interrupt方法中斷它，線程會被激活并收到中斷異常。

常見的協作配合

上面那些場景，其實都是對一個線程的操作，下面來看多線程間的一些配合。

事件一，考試

假設今天考試，20個學生，1個監考老師。規定學生可以提前交卷，即把卷子留下，直接走人就行了。

但老師必須等到所有的學生都走后，才可以收卷子，然后裝訂打包。

如果把學生和老師都看作線程，就是1個線程和20個線程的配合問題，即等20個線程都結束了，這1個線程才開始。

比如20個線程分別在計算數據，等它們都結束后得到20個中間結果，最后這1個線程再進行后續匯總、處理等。
?

static final int COUNT = 20;public static void main(String[] args) throws Exception {new Thread(new Teacher(cdl)).start();sleep(1);for (int i = 0; i < COUNT; i++) {new Thread(new Student(i, cdl)).start();}synchronized (ThreadCo1.class) {ThreadCo1.class.wait();}}static CountDownLatch cdl = new CountDownLatch(COUNT);static class Teacher implements Runnable {CountDownLatch cdl;Teacher(CountDownLatch cdl) {this.cdl = cdl;}@Overridepublic void run() {println("老師發卷子。。。");try {cdl.await();} catch (InterruptedException e) {e.printStackTrace();}println("老師收卷子。。。");}}static class Student implements Runnable {CountDownLatch cdl;int num;Student(int num, CountDownLatch cdl) {this.num = num;this.cdl = cdl;}@Overridepublic void run() {println("學生(%d)寫卷子。。。", num);doingLongTime();println("學生(%d)交卷子。。。", num);cdl.countDown();}}

解說：每完成一個線程，計數器減1，當減到0時，被阻塞的線程自動執行。

?

事件二，旅游

最近景色宜人，公司組織去登山，大伙都來到了山腳下，登山過程自由進行。

但為了在特定的地點拍集體照，規定1個小時后在半山腰集合，誰最后到的，要給大家表演一個節目。

然后繼續登山，在2個小時后，在山頂集合拍照，還是誰最后到的表演節目。

接著開始下山了，在2個小時后在山腳下集合，點名回家，最后到的照例表演節目。
?

static final int COUNT = 5;public static void main(String[] args) throws Exception {for (int i = 0; i < COUNT; i++) {new Thread(new Staff(i, cb)).start();}synchronized (ThreadCo2.class) {ThreadCo2.class.wait();}}static CyclicBarrier cb = new CyclicBarrier(COUNT, new Singer());static class Singer implements Runnable {@Overridepublic void run() {println("為大家唱歌。。。");}}static class Staff implements Runnable {CyclicBarrier cb;int num;Staff(int num, CyclicBarrier cb) {this.num = num;this.cb = cb;}@Overridepublic void run() {println("員工(%d)出發。。。", num);doingLongTime();println("員工(%d)到達地點一。。。", num);try {cb.await();} catch (Exception e) {e.printStackTrace();}println("員工(%d)再出發。。。", num);doingLongTime();println("員工(%d)到達地點二。。。", num);try {cb.await();} catch (Exception e) {e.printStackTrace();}println("員工(%d)再出發。。。", num);doingLongTime();println("員工(%d)到達地點三。。。", num);try {cb.await();} catch (Exception e) {e.printStackTrace();}println("員工(%d)結束。。。", num);}}

?

解說：某個線程到達預設點時就在此等待，等所有的線程都到達時，大家再一起向下個預設點出發。如此循環反復下去。

事件三，勞動

大胖和小白去了創業公司，公司為了節約開支，沒有請專門的保潔人員。讓員工自己掃地和擦桌。

大胖覺得擦桌輕松，就讓小白去掃地。可小白覺得掃地太累，也想擦桌。

為了公平起見，于是決定，每人先干一半，然后交換工具，再接著干對方剩下的那一個半。
?

public static void main(String[] args) throws Exception {new Thread(new Staff("大胖", new Tool("笤帚", "掃地"), ex)).start();new Thread(new Staff("小白", new Tool("抹布", "擦桌"), ex)).start();synchronized (ThreadCo3.class) {ThreadCo3.class.wait();}}static Exchanger<Tool> ex = new Exchanger<>();static class Staff implements Runnable {String name;Tool tool;Exchanger<Tool> ex;Staff(String name, Tool tool, Exchanger<Tool> ex) {this.name = name;this.tool = tool;this.ex = ex;}@Overridepublic void run() {println("%s拿的工具是[%s]，他開始[%s]。。。", name, tool.name, tool.work);doingLongTime();println("%s開始交換工具。。。", name);try {tool = ex.exchange(tool);} catch (Exception e) {e.printStackTrace();}println("%s的工具變為[%s]，他開始[%s]。。。", name, tool.name, tool.work);}}static class Tool {String name;String work;Tool(String name, String work) {this.name = name;this.work = work;}}

解說：兩個線程在預設點交換變量，先到達的等待對方。

事件四，魔性游戲

這是一個充滿魔性的小游戲，由一個團隊一起參加。所有人每隔5秒鐘抽一次簽，每個人有50%的概率留下來或被淘汰。

留下來的人下次抽簽時同樣有50%的概率被淘汰。被淘汰的人下次抽簽時同樣有50%的概率復活。

團隊所有成員都被淘汰完，為挑戰失敗，團隊所有成員都回到游戲中（除剛開始外），為挑戰成功。

比如一開始10人參與游戲，第一輪抽簽后，6人留下，4人淘汰。

第二輪抽簽后，留下的6人中4人被淘汰，淘汰的4人中2人復活，那么目前是4人在游戲中，6人被淘汰。

一直如此繼續下去，直到10人全部被淘汰，或全部回到游戲中。

可見，人數越多，全部被淘汰的概率越小，但全部回到游戲中的概率也越小。

反之，人數越少，全部回到游戲中的概率越大，但全部被淘汰的概率也越大。

是不是很有魔性啊。哈哈。
?

static final int COUNT = 6;public static void main(String[] args) throws Exception {new Thread(new Challenger("張三")).start();new Thread(new Challenger("李四")).start();new Thread(new Challenger("王五")).start();new Thread(new Challenger("趙六")).start();new Thread(new Challenger("大胖")).start();new Thread(new Challenger("小白")).start();synchronized (ThreadCo4.class) {ThreadCo4.class.wait();}}static Phaser ph = new Phaser() {protected boolean onAdvance(int phase, int registeredParties) {println2("第(%d)局，剩余[%d]人", phase, registeredParties);return registeredParties == 0 ||(phase != 0 && registeredParties == COUNT);};};static class Challenger implements Runnable {String name;int state;Challenger(String name) {this.name = name;this.state = 0;}@Overridepublic void run() {println("[%s]開始挑戰。。。", name);ph.register();int phase = 0;int h;while (!ph.isTerminated() && phase < 100) {doingLongTime(5);if (state == 0) {if (Decide.goon()) {h = ph.arriveAndAwaitAdvance();if (h < 0)println("No%d.[%s]繼續，但已勝利。。。", phase, name);elseprintln("No%d.[%s]繼續at(%d)。。。", phase, name, h);} else {state = -1;h = ph.arriveAndDeregister();println("No%d.[%s]退出at(%d)。。。", phase, name, h);}} else {if (Decide.revive()) {state = 0;h = ph.register();if (h < 0)println("No%d.[%s]復活，但已失敗。。。", phase, name);elseprintln("No%d.[%s]復活at(%d)。。。", phase, name, h);} else {println("No%d.[%s]沒有復活。。。", phase, name);}}phase++;}if (state == 0) {ph.arriveAndDeregister();}println("[%s]結束。。。", name);}}static class Decide {static boolean goon() {return random(9) > 4;}static boolean revive() {return random(9) < 5;}}

解說：某個線程到達預設點后，可以選擇等待同伴或自己退出，等大家都到達后，再一起向下一個預設點出發，隨時都可以有新的線程加入，退出的也可以再次加入。

生產與銷售的問題

在現實中，工廠生產出來的產品會先放到倉庫存儲，銷售人員簽了單子后，會從倉庫把產品發給客戶。

如果生產的過快，倉庫里產品越堆越多，直到把倉庫堆滿，那就必須停止生產，因為沒地方放了。

此時只能讓銷售人員趕緊出去簽單子，把產品發出去，倉庫就有了空間，可以恢復生產了。

如果銷售的過快，倉庫里產品越來越少，直到把倉庫清空，那就必須停止銷售，因為沒產品了。

此時只能讓生產人員趕緊生產產品，把產品放到倉庫里，倉庫里就有了產品，可以恢復銷售了。

可能會有人問，為什么不讓生產和銷售直接掛鉤呢，把倉庫這個環節去掉？

這樣會造成兩種不好的情況：

一是突然來了很多單子，生產人員累成死Dog也生產不出來。

二是很長時間沒有單子，生產人員閑成廢Dog也無事可做。

用稍微“專業”點的術語就是此時的生產和銷售是一種強耦合的關系，銷售的波動對生產影響太大。

倉庫就是一個緩沖區，能有效的吸收波動，很大程度上減少波動的傳遞，起到一種解耦作用，由強耦合變成一種松散耦合。

這其實就對應計算機里經典的生產者和消費者問題。

經典的生產者和消費者

一到多個線程充當生產者，生產元素。一到多個線程充當消費者，消費元素。

在兩者之間插入一個隊列（Queue）充當緩沖區，建立起生產者和消費者的松散耦合。

正常情況下，即生產元素的速度和消費元素的速度差不多時，生產者和消費者其實是不需要去關注對方的。

生產者可以一直生產，因為隊列里總是有空間。消費者可以一直消費，因為隊列里總是有元素。即達到一個動態的平衡。

但在特殊情況下，比如生產元素的速度很快，隊列里沒有了空間，此時生產者必須自我“ba工”，開始“睡大覺”。

一旦消費者消費了元素之后，隊列里才會有空間，生產者才可以重啟生產，所以，消費者在消費完元素后有義務去叫醒生產者復工。

更準確的說法應該是，只有在生產者“睡大覺”時，消費者消費完元素后才需要去叫醒生產者。否則，其實可以不用叫醒，因為人家本來就沒睡。

反之，如果消費元素的速度很快，隊列里沒有了元素，只需把上述情況顛倒過來即可。

但這樣的話就會引入一個新的問題，就是要能夠準備的判斷出對方有沒有在睡大覺，為此就必須定義一個狀態變量，在自己即將開始睡大覺時，自己設置下這個變量。

對方通過檢測這個變量，來決定是否進行叫醒操作。當自己被叫醒后，首先要做的就是清除一下這個變量，表明我已經醒來復工了。

這樣就需要多維護一個變量和多了一部分判斷邏輯。可能有些人會覺得可以通過判斷隊列的“空”或“滿”（即隊列中的元素數目）來決定是否進行叫醒操作。

在高并發下，可能剛剛判斷隊列不為空，瞬間之后隊列可能已經變為空的了，這樣會導致邏輯出錯。線程可能永遠無法被叫醒。

因此，綜合所有，生產者每生產一個元素后，都會通知消費者，“現在有元素的，你可以消費”。

同樣，消費者每消費一個元素后，也會通知生產者，“現在有空間的，你可以生產”。

很明顯，這些通知很多時候（即對方沒有睡大覺時）是沒有真正意義的，不過無所謂，只要忽略它們就行了。

就是“寧可錯殺一千，也不放過一個”。首先要保證是正確的，然后才有資格去BB別的。
?

public static void main(String[] args) {Queue queue = new Queue();new Thread(new Producer(queue)).start();new Thread(new Producer(queue)).start();new Thread(new Consumer(queue)).start();}static class Producer implements Runnable {Queue queue;Producer(Queue queue) {this.queue = queue;}@Overridepublic void run() {try {for (int i = 0; i < 10000; i++) {doingLongTime();queue.putEle(random(10000));}} catch (Exception e) {e.printStackTrace();}}}static class Consumer implements Runnable {Queue queue;Consumer(Queue queue) {this.queue = queue;}@Overridepublic void run() {try {for (int i = 0; i < 10000; i++) {doingLongTime();queue.takeEle();}} catch (Exception e) {e.printStackTrace();}}}static class Queue {Lock lock = new ReentrantLock();Condition prodCond = lock.newCondition();Condition consCond = lock.newCondition();final int CAPACITY = 10;Object[] container = new Object[CAPACITY];int count = 0;int putIndex = 0;int takeIndex = 0;public void putEle(Object ele) throws InterruptedException {try {lock.lock();while (count == CAPACITY) {println("隊列已滿：%d，生產者開始睡大覺。。。", count);prodCond.await();}container[putIndex] = ele;println("生產元素：%d", ele);putIndex++;if (putIndex >= CAPACITY) {putIndex = 0;}count++;println("通知消費者去消費。。。");consCond.signalAll();} finally {lock.unlock();}} public Object takeEle() throws InterruptedException { try {lock.lock();while (count == 0) {println("隊列已空：%d，消費者開始睡大覺。。。", count);consCond.await();}Object ele = container[takeIndex];println("消費元素：%d", ele);takeIndex++;if (takeIndex >= CAPACITY) {takeIndex = 0;}count--;println("通知生產者去生產。。。");prodCond.signalAll();return ele;} finally {lock.unlock();}}}

解說：其實就是對await/signalAll的應用，幾乎面試必問。

閱讀目錄（置頂)(長期更新計算機領域知識）https://blog.csdn.net/weixin_43392489/article/details/102380691

閱讀目錄（置頂)(長期更新計算機領域知識）https://blog.csdn.net/weixin_43392489/article/details/102380882

閱讀目錄（置頂)(長期科技領域知識）https://blog.csdn.net/weixin_43392489/article/details/102600114

總結

以上是生活随笔為你收集整理的第三十六期：如果把线程当作一个人来对待，所有问题都瞬间明白了的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。