一道編程題如下： 實例化三個線程，一個線程列印a,一個列印b,一個列印c,三個線程同時執行，要求列印出6個連著的abc 題目分析： 通過題意我們可以得出，本題需要我們使用三個線程，三個線程分別會列印6次字元，關鍵是如何保證順序一定是abc...呢。所以此題需要同步機制來解決問題！ 令列印字元A的線程 ...
一道編程題如下：
實例化三個線程，一個線程列印a,一個列印b,一個列印c,三個線程同時執行，要求列印出6個連著的abc
題目分析：
通過題意我們可以得出，本題需要我們使用三個線程，三個線程分別會列印6次字元，關鍵是如何保證順序一定是abc...呢。所以此題需要同步機制來解決問題！
令列印字元A的線程為ThreadA，列印B的ThreadB，列印C的為ThreadC。問題為三線程間的同步喚醒操作，主要的目的就是使程式按ThreadA->ThreadB->ThreadC-
>ThreadA迴圈執行三個線程，因此本人整理出了三種方式來解決此問題。
一.通過兩個鎖(不推薦，可讀性和安全性比較差)
/** * 基於兩個lock實現連續列印abcabc.... * @author fhr * @since 2017/09/04 */ public class TwoLockPrinter { @Test public void test() throws InterruptedException { // 列印A線程的鎖 Object lockA = new Object(); // 列印B線程的鎖 Object lockB = new Object(); // 列印C線程的鎖 Object lockC = new Object(); ThreadGroup group = new ThreadGroup("xx"); // 列印a的線程 Thread threadA = new Thread(group, new Printer(lockC, lockA, 'A')); // 列印b的線程 Thread threadB = new Thread(group, new Printer(lockA, lockB, 'B')); // 列印c的線程 Thread threadC = new Thread(group, new Printer(lockB, lockC, 'C')); // 依次開啟a b c線程 threadA.start(); Thread.sleep(100); threadB.start(); Thread.sleep(100); threadC.start(); // 主線程迴圈讓出cpu使用權 while (group.activeCount() > 0) { Thread.yield(); } } // 列印線程 private class Printer implements Runnable { // 列印次數 private static final int PRINT_COUNT = 6; // 前一個線程的列印鎖 private final Object fontLock; // 本線程的列印鎖 private final Object thisLock; // 列印字元 private final char printChar; public Printer(Object fontLock, Object thisLock, char printChar) { super(); this.fontLock = fontLock; this.thisLock = thisLock; this.printChar = printChar; } @Override public void run() { // 連續列印PRINT_COUNT次 for (int i = 0; i < PRINT_COUNT; i++) { // 獲取前一個線程的列印鎖 synchronized (fontLock) { // 獲取本線程的列印鎖 synchronized (thisLock) { // 列印字元 System.out.print(printChar); // 通過本線程的列印鎖喚醒後面的線程 // notify和notifyall均可,因為同一時刻只有一個線程在等待 thisLock.notify(); // 不是最後一次則通過fontLock等待被喚醒 // 必須要加判斷，不然能夠列印6次 但6次後就會直接死鎖 if (i < PRINT_COUNT - 1) { try { // 通過fontLock等待被喚醒 fontLock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } } } } }
此解法為了為了確定喚醒、等待的順序，每一個線程必須同時持有兩個對象鎖，才能繼續執行。一個對象鎖是fontLock，就是前一個線程所持有的對象鎖，還有一個就是自身
對象鎖thisLock。主要的思想就是，為了控制執行的順序，必須要先持有fontLock鎖，也就是前一個線程要釋放掉前一個線程自身的對象鎖，當前線程再去申請自身對象鎖，兩
者兼備時列印，之後首先調用thisLock.notify()釋放自身對象鎖，喚醒下一個等待線程，再調用fontLock.wait()釋放prev對象鎖，暫停當前線程，等待再次被喚醒後進入迴圈。運
行上述代碼，可以發現三個線程迴圈列印ABC，共6次。程式運行的主要過程就是A線程最先運行，持有C,A對象鎖，後釋放A鎖，喚醒B。線程B等待A鎖，再申請B鎖，後打
印B，再釋放B鎖，喚醒C，線程C等待B鎖，再申請C鎖，後列印C，再釋放C鎖，喚醒A。看起來似乎沒什麼問題，但如果你仔細想一下，就會發現有問題，就是初始條
件，三個線程按照A,B,C的順序來啟動，按照前面的思考，A喚醒B，B喚醒C，C再喚醒A。但是這種假設依賴於JVM中線程調度、執行的順序，所以需要手動控制他們三個的
啟動順序，即Thread.Sleep(100)
二.通過一個ReentrantLock和三個conditon實現(推薦，安全性，性能和可讀性較高)
/** * 基於一個ReentrantLock和三個conditon實現連續列印abcabc... * @author fhr * @since 2017/09/04 */ public class RcSyncPrinter { @Test public void test() throws InterruptedException { ThreadGroup group = new ThreadGroup("xx"); // 寫鎖 ReentrantLock lock = new ReentrantLock(); // 列印a線程的condition Condition conditionA = lock.newCondition(); // 列印b線程的condition Condition conditionB = lock.newCondition(); // 列印c線程的condition Condition conditionC = lock.newCondition(); // 實例化A線程 Thread printerA = new Thread(group, new Printer(lock, conditionA, conditionB, 'A')); // 實例化B線程 Thread printerB = new Thread(group, new Printer(lock, conditionB, conditionC, 'B')); // 實例化C線程 Thread printerC = new Thread(group, new Printer(lock, conditionC, conditionA, 'C')); // 依次開始A B C線程 printerA.start(); Thread.sleep(100); printerB.start(); Thread.sleep(100); printerC.start(); // 主線程迴圈讓出CPU使用權 while (group.activeCount() > 0) { Thread.yield(); } } // 列印線程 private class Printer implements Runnable { // 列印次數 private static final int PRINT_COUNT = 6; // 列印鎖 private final ReentrantLock reentrantLock; // 本線程列印所需的condition private final Condition thisCondtion; // 下一個線程列印所需要的condition private final Condition nextCondtion; // 列印字元 private final char printChar; public Printer(ReentrantLock reentrantLock, Condition thisCondtion, Condition nextCondition, char printChar) { this.reentrantLock = reentrantLock; this.nextCondtion = nextCondition; this.thisCondtion = thisCondtion; this.printChar = printChar; } @Override public void run() { // 獲取列印鎖 進入臨界區 reentrantLock.lock(); try { // 連續列印PRINT_COUNT次 for (int i = 0; i < PRINT_COUNT; i++) { System.out.print(printChar); // 使用nextCondition喚醒下一個線程 // 因為只有一個線程在等待，所以signal或者signalAll都可以 nextCondtion.signal(); // 不是最後一次則通過thisCondtion等待被喚醒 // 必須要加判斷，不然能夠列印6次 但6次後就會直接死鎖 if (i < PRINT_COUNT - 1) { try { // 本線程讓出鎖並等待喚醒 thisCondtion.await(); } catch (InterruptedException e) { e.printStackTrace(); } } } } finally { // 釋放列印鎖 reentrantLock.unlock(); } } } }
仔細想想本問題，既然同一時刻只能有一個線程列印字元，那我們為什麼不使用一個同步鎖ReentrantLock？線程之間的喚醒操作可以通過Condition實現，且Condition可以有
多個，每個condition.await阻塞只能通過該condition的signal/signalall來喚醒！這是synchronized關鍵字所達不到的，那我們就可以給每個列印線程一個自身的condition和下一
個線程的condition，每次列印字元後，調用下一個線程的condition.signal來喚醒下一個線程，然後自身再通過自己的condition.await來釋放鎖並等待喚醒。
三.通過一個鎖和一個狀態變數來實現（推薦）
/** * 基於一個鎖和一個狀態變數實現連續列印abcabc... * @author fhr * @since 2017/09/04 */ public class StateLockPrinter { //狀態變數 private volatile int state=0; @Test public void test() throws InterruptedException { //鎖 Object lock=new Object(); ThreadGroup group=new ThreadGroup("xx"); //列印A的線程 Thread threadA=new Thread(group,new Printer(lock, 0,1, 'A')); //列印B的線程 Thread threadB=new Thread(group,new Printer(lock, 1,2, 'B')); //列印C的線程 Thread threadC=new Thread(group,new Printer(lock, 2,0, 'C')); //一次啟動A B C線程 threadA.start(); Thread.sleep(1000); threadB.start(); Thread.sleep(1000); threadC.start(); //迴圈檢查線程組合的活的線程數量 while (group.activeCount()>0) { //讓出CPU使用權 Thread.yield(); } } //列印線程 private class Printer implements Runnable{ //列印次數 private static final int PRINT_COUNT=6; //列印鎖 private final Object printLock; //列印標誌位 和state變數相關 private final int printFlag; //後繼線程的線程的列印標誌位，state變數相關 private final int nextPrintFlag; //該線程的列印字元 private final char printChar; public Printer(Object printLock, int printFlag,int nextPrintFlag, char printChar) { super(); this.printLock = printLock; this.printFlag=printFlag; this.nextPrintFlag=nextPrintFlag; this.printChar = printChar; } @Override public void run() { //獲取列印鎖 進入臨界區 synchronized (printLock) { //連續列印PRINT_COUNT次 for(int i=0;i<PRINT_COUNT;i++){ //迴圈檢驗標誌位 每次都阻塞然後等待喚醒 while (state!=printFlag) { try { printLock.wait(); } catch (InterruptedException e) { return; } } //列印字元 System.out.print(printChar); //設置狀態變數為下一個線程的標誌位 state=nextPrintFlag; //註意要notifyall，不然會死鎖，因為notify只通知一個， //但是同時等待的是兩個,如果喚醒的不是正確那個就會沒人喚醒，死鎖了 printLock.notifyAll(); } } } } }
狀態變數是一個volatile的整型變數，0代表列印a,1代表列印b,2代表列印c,三個線程都迴圈檢驗標誌位，通過阻塞前和阻塞後兩次判斷可以確保當前列印的正確順序，隨後線程
列印字元，然後設置下一個狀態字元，喚醒其它線程，然後重新進入迴圈。
補充題
三個Java多線程迴圈列印遞增的數字，每個線程列印5個數值，列印周期1-75，同樣的解法：
/** * 數字列印，三個線程同時列印數字， * 第一個線程列印12345，第二個線程列印678910 ......... * @author fhr * @since 2017/09/04 */ public class NumberPrinter { //列印計數器 private final AtomicInteger counter=new AtomicInteger(0); @Test public void test() throws InterruptedException { //列印鎖 ReentrantLock reentrantLock=new ReentrantLock(); //列印A線程的Condition Condition conditionA=reentrantLock.newCondition(); //列印B線程的Condition Condition conditionB=reentrantLock.newCondition(); //列印C線程的Condition Condition conditionC=reentrantLock.newCondition(); ThreadGroup group=new ThreadGroup("xx"); //列印線程A Thread threadA=new Thread(group,new Printer(reentrantLock,conditionA, conditionB)); //列印線程B Thread threadB=new Thread(group,new Printer(reentrantLock, conditionB, conditionC)); //列印線程C Thread threadC=new Thread(group,new Printer(reentrantLock, conditionC, conditionA)); // 依次開啟a b c線程 threadA.start(); Thread.sleep(100); threadB.start(); Thread.sleep(100); threadC.start(); while (group.activeCount()>0) { Thread.yield(); } } private class Printer implements Runnable{ //總共需要列印TOTAL_PRINT_COUNT次 private static final int TOTAL_PRINT_COUNT=5; //每次列印PER_PRINT_COUNT次 private static final int PER_PRINT_COUNT=5; //列印鎖 private final ReentrantLock reentrantLock; //前一個線程的condition private final Condition afterCondition; //本線程的condition private final Condition thisCondtion; public Printer(ReentrantLock reentrantLock, Condition thisCondtion,Condition afterCondition) { super(); this.reentrantLock = reentrantLock; this.afterCondition = afterCondition; this.thisCondtion = thisCondtion; } @Override public void run() { //進入臨界區 reentrantLock.lock(); try { //迴圈列印TOTAL_PRINT_COUNT次 for(int i=0;i<TOTAL_PRINT_COUNT;i++){ //列印操作 for(int j=0;j<PER_PRINT_COUNT;j++){ System.out.println(counter.incrementAndGet()); } //通過afterCondition通知後麵線程 afterCondition.signalAll(); if(i<=TOTAL_PRINT_COUNT-1){ try { //本線程釋放鎖並等待喚醒 thisCondtion.await(); } catch (InterruptedException e) { e.printStackTrace(); } } } } finally { reentrantLock.unlock(); } } } }
