2. 程式人生 > >面試題--三個執行緒迴圈列印ABC10次的幾種解決方法

面試題--三個執行緒迴圈列印ABC10次的幾種解決方法

阿新 • • 發佈：2019-01-04
  • 使用sleep
  • 使用synchronized, wait和notifyAll
  • 使用Lock 和 Condition
  • 使用Semaphore
  • 使用AtomicInteger


下面依次給出每種解決方案的程式碼：

使用sleep
Java程式碼
  1. package my.thread.test;   
  2. /**  
  3.  * @author Eric  
  4.  */
  5. publicclass SleepExample extends Thread {   
  6. privatestaticint currentCount = 0;   
  7. public SleepExample(String name) {   
  8. this
    .setName(name);   
  9.     }   
  10. @Override
  11. publicvoid run() {   
  12. while (currentCount < 30) {   
  13. switch (currentCount % 3) {   
  14. case0:   
  15. if ("A".equals(getName())) {   
  16.                     printAndIncrease();   
  17.                 }   
  18. break;   
  19. case1:   
  20. if ("B".equals(getName())) {   
  21.                     printAndIncrease();   
  22.                 }   
  23. break;   
  24. case2:   
  25. if ("C".equals(getName())) {   
  26.                     printAndIncrease();   
  27.                 }   
  28. break;   
  29.             }   
  30.         }   
  31.     }   
  32. privatevoid printAndIncrease() {   
  33.         print();   
  34.         increase();   
  35.     }   
  36. privatevoid print() {   
  37.         System.out.println(getName());   
  38. if ("C".equals(getName())) {   
  39.             System.out.println();   
  40.         }   
  41.     }   
  42. privatevoid increase() {   
  43.         currentCount++;   
  44.     }   
  45. publicstaticvoid main(String[] args) {   
  46. new SleepExample("A").start();   
  47. new SleepExample("B").start();   
  48. new SleepExample("C").start();   
  49.     }   
  50. }  
<span style="font-family:KaiTi_GB2312;font-size:18px;">package my.thread.test;

/**
 * @author Eric
 */
public class SleepExample extends Thread {

	private static int currentCount = 0;

	public SleepExample(String name) {
		this.setName(name);
	}

	@Override
	public void run() {
		while (currentCount < 30) {
			switch (currentCount % 3) {
			case 0:
				if ("A".equals(getName())) {
					printAndIncrease();
				}
				break;
			case 1:
				if ("B".equals(getName())) {
					printAndIncrease();
				}
				break;
			case 2:
				if ("C".equals(getName())) {
					printAndIncrease();
				}
				break;
			}
		}

	}

	private void printAndIncrease() {
		print();
		increase();
	}

	private void print() {
		System.out.println(getName());
		if ("C".equals(getName())) {
			System.out.println();
		}
	}

	private void increase() {
		currentCount++;
	}

	public static void main(String[] args) {
		new SleepExample("A").start();
		new SleepExample("B").start();
		new SleepExample("C").start();
	}

}</span>


使用synchronized, wait和notifyAll

Java程式碼 複製程式碼
  1. package my.thread.test;   
  2. import java.util.concurrent.ExecutorService;   
  3. import java.util.concurrent.Executors;   
  4. publicclass PrintThreadExample {   
  5. publicstaticvoid main(String[] args) {   
  6.         PrintThreadExample example = new PrintThreadExample();   
  7.         LetterPrinter letterPrinter = example.new LetterPrinter();   
  8.         ExecutorService service = Executors.newFixedThreadPool(3);   
  9.         service.execute(example.new PrintRunnable(letterPrinter, 'A'));   
  10.         service.execute(example.new PrintRunnable(letterPrinter, 'B'));   
  11.         service.execute(example.new PrintRunnable(letterPrinter, 'C'));   
  12.         service.shutdown();   
  13.     }   
  14. privateclass LetterPrinter {   
  15. privatechar letter = 'A';   
  16. publicvoid print() {   
  17.             System.out.println(letter);   
  18. if ('C' == letter) {   
  19.                 System.out.println();   
  20.             }   
  21.         }   
  22. publicvoid nextLetter() {   
  23. switch (letter) {   
  24. case'A':   
  25.                 letter = 'B';   
  26. break;   
  27. case'B':   
  28.                 letter = 'C';   
  29. break;   
  30. case'C':   
  31.                 letter = 'A';   
  32. break;   
  33.             }   
  34.         }   
  35. /**  
  36.          * @return the letter  
  37.          */
  38. publicchar getLetter() {   
  39. return letter;   
  40.         }   
  41.     }   
  42. privateclass PrintRunnable implements Runnable {   
  43. private LetterPrinter letterPrinter = null;   
  44. privatechar letter = ' ';   
  45. /**  
  46.          * @param letterPrinter  
  47.          * @param letter  
  48.          */
  49. public PrintRunnable(LetterPrinter letterPrinter, char letter) {   
  50. super();   
  51. this.letterPrinter = letterPrinter;   
  52. this.letter = letter;   
  53.         }   
  54. publicvoid run() {   
  55. for (int i = 0; i < 10; i++) {   
  56. synchronized (letterPrinter) {   
  57. while (letter != letterPrinter.getLetter()) {   
  58. try {   
  59.                             letterPrinter.wait();   
  60.                         } catch (InterruptedException e) {   
  61. // TODO Auto-generated catch block
  62.                             e.printStackTrace();   
  63.                         }   
  64.                     }   
  65.                     letterPrinter.print();   
  66.                     letterPrinter.nextLetter();   
  67.                     letterPrinter.notifyAll();   
  68.                 }   
  69.             }   
  70.         }   
  71.     }   
  72. }  
<span style="font-family:KaiTi_GB2312;font-size:18px;">package my.thread.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PrintThreadExample {

	public static void main(String[] args) {
		PrintThreadExample example = new PrintThreadExample();

		LetterPrinter letterPrinter = example.new LetterPrinter();

		ExecutorService service = Executors.newFixedThreadPool(3);

		service.execute(example.new PrintRunnable(letterPrinter, 'A'));
		service.execute(example.new PrintRunnable(letterPrinter, 'B'));
		service.execute(example.new PrintRunnable(letterPrinter, 'C'));

		service.shutdown();
	}

	private class LetterPrinter {
		private char letter = 'A';

		public void print() {
			System.out.println(letter);
			if ('C' == letter) {
				System.out.println();
			}
		}

		public void nextLetter() {
			switch (letter) {
			case 'A':
				letter = 'B';
				break;
			case 'B':
				letter = 'C';
				break;
			case 'C':
				letter = 'A';
				break;
			}
		}

		/**
		 * @return the letter
		 */
		public char getLetter() {
			return letter;
		}

	}

	private class PrintRunnable implements Runnable {

		private LetterPrinter letterPrinter = null;

		private char letter = ' ';

		/**
		 * @param letterPrinter
		 * @param letter
		 */
		public PrintRunnable(LetterPrinter letterPrinter, char letter) {
			super();
			this.letterPrinter = letterPrinter;
			this.letter = letter;
		}

		public void run() {
			for (int i = 0; i < 10; i++) {
				synchronized (letterPrinter) {
					while (letter != letterPrinter.getLetter()) {
						try {
							letterPrinter.wait();
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}

					letterPrinter.print();
					letterPrinter.nextLetter();
					letterPrinter.notifyAll();

				}
			}

		}

	}

}</span>


JDK 1.5 引入J.U.C包之後，也給我們提供了更多實現多執行緒程式的選擇: Condition, 原子類AtomicInteger以及Semaphore等。


使用Lock 和 Condition Java程式碼 複製程式碼
  1. package my.thread.test;   
  2. import java.util.concurrent.ExecutorService;   
  3. import java.util.concurrent.Executors;   
  4. import java.util.concurrent.locks.Condition;   
  5. import java.util.concurrent.locks.Lock;   
  6. import java.util.concurrent.locks.ReentrantLock;   
  7. import java.util.logging.Logger;   
  8. /**  
  9.  * 題目：有三個執行緒分別列印A、B、C,請用多執行緒程式設計實現，在螢幕上迴圈列印10次ABCABC…  
  10.  *   
  11.  * 本程式採用Lock和Condition來實現。  
  12.  *   
  13.  * @author Eric  
  14.  *   
  15.  */
  16. publicclass ConditionExample {   
  17. private Lock lock = new ReentrantLock();   
  18. private Condition conditionA = lock.newCondition();   
  19. private Condition conditionB = lock.newCondition();   
  20. private Condition conditionC = lock.newCondition();   
  21. /** 當前執行緒的名字 */
  22. privatechar currentThreadName = 'A';   
  23. privatestaticfinal Logger logger = Logger   
  24.             .getLogger("my.thread.test.OrderPrintTest");   
  25. publicstaticvoid main(String[] args) {   
  26.         ConditionExample ce = new ConditionExample();   
  27.         ExecutorService service = Executors.newFixedThreadPool(3);   
  28.         service.execute(ce.new ThreadA());   
  29.         service.execute(ce.new ThreadB());   
  30.         service.execute(ce.new ThreadC());   
  31.         service.shutdown();   
  32.     }   
  33. privateclass ThreadA implements Runnable {   
  34. publicvoid run() {   
  35. for (int i = 0; i < 10; i++) {   
  36.                 lock.lock();   
  37. try {   
  38. while (currentThreadName != 'A') {   
  39. try {   
  40. /*  
  41.                              * 如果當前執行緒名字不是A，那麼ThreadA就處理等待狀態  
  42.                              */
  43.                             conditionA.await();   
  44.                         } catch (InterruptedException e) {   
  45.                             logger.severe(e.getLocalizedMessage());   
  46.                         }   
  47.                     }   
  48. /*  
  49.                      * 打印出第幾遍以及A資訊  
  50.                      */
  51.                     System.out.println(String.format("第%d遍", i + 1));   
  52.                     System.out.println("A");   
  53. /*  
  54.                      * 將當前執行緒名置為B， 然後通知ThreadB執行  
  55.                      */
  56.                     currentThreadName = 'B';   
  57.                     conditionB.signal();   
  58.                 } finally {   
  59.                     lock.unlock();   
  60.                 }   
  61.             }   
  62.         }   
  63.     }   
  64. privateclass ThreadB implements Runnable {   
  65. publicvoid run() {   
  66. for (int i = 0; i < 10; i++) {   
  67.                 lock.lock();   
  68. try {   
  69. while (currentThreadName != 'B') {   
  70. try {   
  71. /*  
  72.                              * 如果當前執行緒名字不是B，那麼ThreadB就處理等待狀態  
  73.                              */
  74.                             conditionB.await();   
  75.                         } catch (InterruptedException e) {   
  76.                             logger.severe(e.getLocalizedMessage());   
  77.                         }   
  78.                     }   
  79. /*  
  80.                      * 列印資訊B  
  81.                      */
  82.                     System.out.println("B");   
  83. /*  
  84.                      * 將當前執行緒值置為C 並通過ThreadC來執行  
  85.                      */
  86.                     currentThreadName = 'C';   
  87.                     conditionC.signal();   
  88.                 } finally {   
  89.                     lock.unlock();   
  90.                 }   
  91.             }   
  92.         }   
  93.     }   
  94. privateclass ThreadC implements Runnable {   
  95. publicvoid run() {   
  96. for (int i = 0; i < 10; i++) {   
  97.                 lock.lock();   
  98. try {   
  99. while (currentThreadName != 'C') {   
  100. try {   
  101. /*  
  102.                              * 如果當前執行緒名字不是C，那麼ThreadC就處理等待狀態  
  103.                              */
  104.                             conditionC.await();   
  105.                         } catch (InterruptedException e) {   
  106.                             logger.severe(e.getLocalizedMessage());   
  107.                         }   
  108.                     }   
  109. /*  
  110.                      * 列印資訊C  
  111.                      */
  112.                     System.out.println("C");   
  113.                     System.out.println();   
  114. /*  
  115.                      * 將當前執行緒值置為A 並通過ThreadA來執行  
  116.                      */
  117.                     currentThreadName = 'A';   
  118.                     conditionA.signal();   
  119.                 } finally {   
  120.                     lock.unlock();   
  121.                 }   
  122.             }   
  123.         }   
  124.     }   
  125. }  
<span style="font-family:KaiTi_GB2312;font-size:18px;">package my.thread.test;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.logging.Logger;

/**
 * 題目：有三個執行緒分別列印A、B、C,請用多執行緒程式設計實現，在螢幕上迴圈列印10次ABCABC…
 * 
 * 本程式採用Lock和Condition來實現。
 * 
 * @author Eric
 * 
 */
public class ConditionExample {

	private Lock lock = new ReentrantLock();

	private Condition conditionA = lock.newCondition();
	private Condition conditionB = lock.newCondition();
	private Condition conditionC = lock.newCondition();

	/** 當前執行緒的名字 */
	private char currentThreadName = 'A';

	private static final Logger logger = Logger
			.getLogger("my.thread.test.OrderPrintTest");

	public static void main(String[] args) {

		ConditionExample ce = new ConditionExample();

		ExecutorService service = Executors.newFixedThreadPool(3);
		service.execute(ce.new ThreadA());
		service.execute(ce.new ThreadB());
		service.execute(ce.new ThreadC());

		service.shutdown();
	}

	private class ThreadA implements Runnable {
		public void run() {

			for (int i = 0; i < 10; i++) {
				lock.lock();
				try {
					while (currentThreadName != 'A') {
						try {
							/*
							 * 如果當前執行緒名字不是A，那麼ThreadA就處理等待狀態
							 */
							conditionA.await();
						} catch (InterruptedException e) {
							logger.severe(e.getLocalizedMessage());
						}
					}

					/*
					 * 打印出第幾遍以及A資訊
					 */
					System.out.println(String.format("第%d遍", i + 1));
					System.out.println("A");

					/*
					 * 將當前執行緒名置為B， 然後通知ThreadB執行
					 */
					currentThreadName = 'B';
					conditionB.signal();

				} finally {
					lock.unlock();
				}
			}
		}

	}

	private class ThreadB implements Runnable {
		public void run() {
			for (int i = 0; i < 10; i++) {
				lock.lock();
				try {
					while (currentThreadName != 'B') {
						try {
							/*
							 * 如果當前執行緒名字不是B，那麼ThreadB就處理等待狀態
							 */
							conditionB.await();
						} catch (InterruptedException e) {
							logger.severe(e.getLocalizedMessage());
						}
					}

					/*
					 * 列印資訊B
					 */
					System.out.println("B");

					/*
					 * 將當前執行緒值置為C 並通過ThreadC來執行
					 */
					currentThreadName = 'C';
					conditionC.signal();

				} finally {
					lock.unlock();
				}
			}

		}

	}

	private class ThreadC implements Runnable {

		public void run() {
			for (int i = 0; i < 10; i++) {
				lock.lock();
				try {
					while (currentThreadName != 'C') {
						try {
							/*
							 * 如果當前執行緒名字不是C，那麼ThreadC就處理等待狀態
							 */
							conditionC.await();
						} catch (InterruptedException e) {
							logger.severe(e.getLocalizedMessage());
						}
					}

					/*
					 * 列印資訊C
					 */
					System.out.println("C");
					System.out.println();

					/*
					 * 將當前執行緒值置為A 並通過ThreadA來執行
					 */
					currentThreadName = 'A';
					conditionA.signal();

				} finally {
					lock.unlock();
				}

			}
		}
	}
}</span>



使用Semaphore
Java程式碼 複製程式碼
  1. package my.thread.test;   
  2. import java.util.concurrent.ExecutorService;   
  3. import java.util.concurrent.Executors;   
  4. import java.util.concurrent.Semaphore;   
  5. publicclass SemaphoresExample {   
  6. private Semaphore semaphoresA = new Semaphore(1);   
  7. private

    相關推薦

    面試題--三個執行緒迴圈列印ABC10次的幾種解決方法

    使用sleep 使用synchronized, wait和notifyAll 使用Lock 和 Condition 使用Semaphore 使用AtomicInteger 下面依次給出每種解決方案的程式碼： 使用sleep Java程式碼 package my.thread.test;  

    面試題--三個執行緒迴圈列印ABC 10次：另類解決方法

    看到網上有各種寫法，但總感覺的看起來晦澀難懂。於是自己寫了一個，如下： import java.util.concurrent.atomic.AtomicBoolean; class Printer extends Thread { public AtomicBoo

    Java三個執行緒迴圈列印

    先上效果圖：  目錄 資源 測試 資源 這裡用了condition 執行流程：執行緒1執行完，讓執行緒2醒來工作；執行緒2執行完，讓執行緒3醒來工作；執行緒3執行完，讓執行緒1醒來工作 原理（都是按最壞的情況分析）： ①一開始3個執行緒搶鎖，如果執行緒

    Java多執行緒迴圈列印ABC的5種實現方法

    https://blog.csdn.net/weixin_39723337/article/details/80352783   題目：3個執行緒迴圈列印ABC，其中A列印3次，B列印2次，C列印1次，迴圈列印2輪一.Synchronized同步法思路：使用synchronized、wait、n

    開啟3個執行緒依次列印ABC10次

    題目： 編寫一個程式，開啟3個執行緒，這3個執行緒的ID分別為A、B、C，每個執行緒將自己的ID在螢幕上列印10遍，要求輸出結果必須按ABC的順序顯示；如：ABCABC….依次遞推。 #include <stdio.h> #include <wind

    java多執行緒面試題：三個執行緒順序列印ABC，重複10次

    這個面試題，比較經典。有不同的解決思路。有的博文是用Join去實現。我面試的時候也是第一個想到的是用join叫A執行緒等待B執行緒執行完再執行。這樣的思路能實現，但是不好。雖然當時湊合著說服了面試官。先把程式碼貼出來 private Thread aThread,bThr

    Java多執行緒--三個執行緒分別列印a,b,c.請用多執行緒實現迴圈列印15次abc

    掃盲: 想想自己多執行緒解決生產消費者問題就知道個synchronized,真是慚愧 為做此題目特意學習新的多執行緒知識–ReentrantLock跟synchronized一樣都是Java中的可重入鎖(可以在內部鎖中拿到外部鎖) Con

    三個執行緒分別列印ABC,按順序輸出ABCABC...

    #include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <unistd.h> #include <vector> #include

    3個執行緒迴圈列印ABC

    三個執行緒迴圈列印ABC多次，要求同時開啟多個執行緒 核心思路：三個執行緒分別列印A，B，C；一個執行完後喚醒另外一個執行緒。主要使用Object.wait()和Object.notify()這兩個方法。 實現方法 A->B， B->C,

    一起做面試題--Java多執行緒交替列印

    這道面試題的內容是，要求兩個執行緒交替列印，打印出"12A34B56C78D910E1112F1314G1516H1718I1920J2122K2324L2526M2728N2930O3132P3334Q3536R3738S3940T4142U4344V4546W4748X

    一個關於執行緒的經典面試題，要求用三個執行緒，按順序列印1,2,3,4,5.... 71,72,73,74, 75. 執行緒1先列印1,2,3,4,5, * 然後是執行緒2列印6,7,8,9,10, 然後是

    package thread; /**  *   * 一個關於執行緒的經典面試題，要求用三個執行緒，按順序列印1,2,3,4,5.... 71,72,73,74, 75. 執行緒1先列印1,2,3,4,5,  * 然後是執行緒2列印6,7,8,9,10, 然後是執行緒3列印

    多執行緒程式設計（二）——面試題，每個執行緒只打印一種字元，多個執行緒協同順序列印n次字串（求大神的其他實現方案）

    （這個是歡聚時刻（YY）的筆試題，在筆試的時候沒有寫出來，後來自己寫了出來，希望大神能給出更優秀的解決方案……ps：現在面試官總有面試時問筆試程式設計題思路的習慣，呵呵） 題目簡述： 輸入一個字串以

    java實現三個執行緒A B C,A執行緒列印A之後才能B執行緒列印B，然後接著C執行緒執行列印C,繼而迴圈下去

    最近看到有人提問這個問題，而且好多人又是轉載的，寫了一大堆，看的我頭都大了。於是自己做了個小程式輕鬆解決。 附上程式碼： package pcitc; import java.util.concurrent.locks.Lock; import java.util.conc

    用三個執行緒按順序迴圈列印abc 三個字母，比如abcabcabc

    執行緒類 import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Ree

    java實現【有三個執行緒ID分別是A、B、C,請有多線程式設計實現,在螢幕上迴圈列印10次ABC.】

    該題應屬於生產者消費者模式一類 生產者消費者模式：根據標誌位來發訊息，實現對執行緒的控制。 直接貼答案了，請各位大蝦們指正哦。 建立三個執行緒 如下：ThreadA、ThreadB、ThreadC public class ThreadA implements Ru

    經典的一道JAVA面試題：A、B執行緒迴圈列印A、B

    1、問題描述 通過Java多執行緒方式實現迴圈順序列印A、B，而且保證無論多少次迴圈，都不亂序？ 2、問題的解決方案 其實這個問題，背後考察的是一個生產者和消費者的問題。即：要保證當前一個執行緒的任務完成之後，再去執行另一個執行緒的任務。由多種解決方法： 1、利用w

    多執行緒（至少三個執行緒）分別列印A、B、C，要求按ABC的順序迴圈列印10次。

    看到網上一道題，三個執行緒按順序列印A、B、C迴圈10次，於是自己按幾種方法也寫了一下： 一、用執行緒池、Lock鎖和condition(Object 監視器方法的使用)組合使用實現： package multithread; import java.util.concu

    面試題一：實現兩個執行緒交替列印數字

    public class Solution1 { private static Object lock = new Object(); private static int i = 1; public static void main(String[] args)

    曹工雜談：一道阿里面試題，兩個執行緒交替列印奇偶數

    一、前言 這些天忙著寫業務程式碼，曹工說Tomcat系列暫時沒時間寫，先隨便寫點其他的。 逛部落格園的時候，發現一篇園友的阿里面試文章，https://www.cnblogs.com/crossoverJie/p/9404789.html。 裡面提到了：兩個執行緒，交替列印奇偶數這道筆試題。 看了園友

    編寫一個程式，啟動三個執行緒，三個執行緒的名稱分別是 A，B，C； 每個執行緒將自己的名稱在螢幕上列印5遍，列印順序是ABCABC...

    設定標誌位flag 當flag==1時，列印A 當flag==2時，列印B 當flag==3時，列印C 用count控制列印的次數，題目要求列印5遍，即15個字元 這裡的用notifyAll()的原因：是要把其餘兩個全都喚醒，因為如果用notify