面试题--三个线程循环打印ABC10次的几种解决方法
博客分类：多线程 Java 面试题 多线程 java thread Semaphore Condition最近发现公司有份笔试试卷中有道多线程的 题目： 有三个线程分别打印A、B、C,请用多线程编程实现，在屏幕上循环打印10次ABCABC…

这个最早好像是迅雷的面试题目吧，看到了然后就想重温一下这个题目的解决方法。

在本文中，给出了五种这个题目的解决方法：

• 使用sleep
• 使用synchronized, wait和notifyAll
• 使用Lock 和 Condition
• 使用Semaphore
• 使用AtomicInteger

下面依次给出每种解决方案的代码：

使用sleep
Java代码
文章图片

1. package my.thread.test;
3. /**
4. * @author Eric
5. */
6. public class SleepExample extends Thread {
8. private static int currentCount = 0;
10. public SleepExample(String name) {
11. this.setName(name);
12. }
14. @Override
15. public void run() {
16. while (currentCount < 30) {
17. switch (currentCount % 3) {
18. case 0:
19. if ("A".equals(getName())) {
20. printAndIncrease();
21. }
22. break;
23. case 1:
24. if ("B".equals(getName())) {
25. printAndIncrease();
26. }
27. break;
28. case 2:
29. if ("C".equals(getName())) {
30. printAndIncrease();
31. }
32. break;
33. }
34. }
36. }
38. private void printAndIncrease() {
39. print();
40. increase();
41. }
43. private void print() {
44. System.out.println(getName());
45. if ("C".equals(getName())) {
46. System.out.println();
47. }
48. }
50. private void increase() {
51. currentCount++;
52. }
54. public static void main(String[] args) {
55. new SleepExample("A").start();
56. new SleepExample("B").start();
57. new SleepExample("C").start();
58. }
60. }

使用synchronized, wait和notifyAll

Java代码
文章图片

1. package my.thread.test;
3. import java.util.concurrent.ExecutorService;
4. import java.util.concurrent.Executors;
6. public class PrintThreadExample {
8. public static void main(String[] args) {
9. PrintThreadExample example = new PrintThreadExample();
11. LetterPrinter letterPrinter = example.new LetterPrinter();
13. ExecutorService service = Executors.newFixedThreadPool(3);
15. service.execute(example.new PrintRunnable(letterPrinter, 'A'));
16. service.execute(example.new PrintRunnable(letterPrinter, 'B'));
17. service.execute(example.new PrintRunnable(letterPrinter, 'C'));
19. service.shutdown();
20. }
22. private class LetterPrinter {
23. private char letter = 'A';
25. public void print() {
26. System.out.println(letter);
27. if ('C' == letter) {
28. System.out.println();
29. }
30. }
32. public void nextLetter() {
33. switch (letter) {
34. case 'A':
35. letter = 'B';
36. break;
37. case 'B':
38. letter = 'C';
39. break;
40. case 'C':
41. letter = 'A';
42. break;
43. }
44. }
46. /**
47. * @return the letter
48. */
49. public char getLetter() {
50. return letter;
51. }
53. }
55. private class PrintRunnable implements Runnable {
57. private LetterPrinter letterPrinter = null;
59. private char letter = ' ';
61. /**
62. * @param letterPrinter
63. * @param letter
64. */
65. public PrintRunnable(LetterPrinter letterPrinter, char letter) {
66. super();
67. this.letterPrinter = letterPrinter;
68. this.letter = letter;
69. }
71. public void run() {
72. for (int i = 0; i < 10; i++) {
73. synchronized (letterPrinter) {
74. while (letter != letterPrinter.getLetter()) {
75. try {
76. letterPrinter.wait();
77. } catch (InterruptedException e) {
78. // TODO Auto-generated catch block
79. e.printStackTrace();
80. }
81. }
83. letterPrinter.print();
84. letterPrinter.nextLetter();
85. letterPrinter.notifyAll();
87. }
88. }
90. }
92. }
94. }

JDK 1.5 引入J.U.C包之后，也给我们提供了更多实现多线程程序的选择: Condition, 原子类AtomicInteger以及Semaphore等。


使用Lock 和 Condition
Java代码
文章图片

1. package my.thread.test;
3. import java.util.concurrent.ExecutorService;
4. import java.util.concurrent.Executors;
5. import java.util.concurrent.locks.Condition;
6. import java.util.concurrent.locks.Lock;
7. import java.util.concurrent.locks.ReentrantLock;
8. import java.util.logging.Logger;
10. /**
11. * 题目：有三个线程分别打印A、B、C,请用多线程编程实现，在屏幕上循环打印10次ABCABC…
12. *
13. * 本程序采用Lock和Condition来实现。
14. *
15. * @author Eric
16. *
17. */
18. public class ConditionExample {
20. private Lock lock = new ReentrantLock();
22. private Condition conditionA = lock.newCondition();
23. private Condition conditionB = lock.newCondition();
24. private Condition conditionC = lock.newCondition();
26. /** 当前线程的名字 */
27. private char currentThreadName = 'A';
29. private static final Logger logger = Logger
30. .getLogger("my.thread.test.OrderPrintTest");
32. public static void main(String[] args) {
34. ConditionExample ce = new ConditionExample();
36. ExecutorService service = Executors.newFixedThreadPool(3);
37. service.execute(ce.new ThreadA());
38. service.execute(ce.new ThreadB());
39. service.execute(ce.new ThreadC());
41. service.shutdown();
42. }
44. private class ThreadA implements Runnable {
45. public void run() {
47. for (int i = 0; i < 10; i++) {
48. lock.lock();
49. try {
50. while (currentThreadName != 'A') {
51. try {
52. /*
53. * 如果当前线程名字不是A，那么ThreadA就处理等待状态
54. */
55. conditionA.await();
56. } catch (InterruptedException e) {
57. logger.severe(e.getLocalizedMessage());
58. }
59. }
61. /*
62. * 打印出第几遍以及A信息
63. */
64. System.out.println(String.format("第%d遍", i + 1));
65. System.out.println("A");
67. /*
68. * 将当前线程名置为B， 然后通知ThreadB执行
69. */
70. currentThreadName = 'B';
71. conditionB.signal();
73. } finally {
74. lock.unlock();
75. }
76. }
77. }
79. }
81. private class ThreadB implements Runnable {
82. public void run() {
83. for (int i = 0; i < 10; i++) {
84. lock.lock();
85. try {
86. while (currentThreadName != 'B') {
87. try {
88. /*
89. * 如果当前线程名字不是B，那么ThreadB就处理等待状态
90. */
91. conditionB.await();
92. } catch (InterruptedException e) {
93. logger.severe(e.getLocalizedMessage());
94. }
95. }
97. /*
98. * 打印信息B
99. */
100. System.out.println("B");
102. /*
103. * 将当前线程值置为C 并通过ThreadC来执行
104. */
105. currentThreadName = 'C';
106. conditionC.signal();
108. } finally {
109. lock.unlock();
110. }
111. }
113. }
115. }
117. private class ThreadC implements Runnable {
119. public void run() {
120. for (int i = 0; i < 10; i++) {
121. lock.lock();
122. try {
123. while (currentThreadName != 'C') {
124. try {
125. /*
126. * 如果当前线程名字不是C，那么ThreadC就处理等待状态
127. */
128. conditionC.await();
129. } catch (InterruptedException e) {
130. logger.severe(e.getLocalizedMessage());
131. }
132. }
134. /*
135. * 打印信息C
136. */
137. System.out.println("C");
138. System.out.println();
140. /*
141. * 将当前线程值置为A 并通过ThreadA来执行
142. */
143. currentThreadName = 'A';
144. conditionA.signal();
146. } finally {
147. lock.unlock();
148. }
150. }
151. }
152. }
153. }

使用Semaphore
Java代码
文章图片

1. package my.thread.test;
3. import java.util.concurrent.ExecutorService;
4. import java.util.concurrent.Executors;
5. import java.util.concurrent.Semaphore;
7. public class SemaphoresExample {
9. private Semaphore semaphoresA = new Semaphore(1);
10. private Semaphore semaphoresB = new Semaphore(0);
11. private Semaphore semaphoresC = new Semaphore(0);
13. public static void main(String[] args) {
14. SemaphoresExample example = new SemaphoresExample();
15. ExecutorService service = Executors.newFixedThreadPool(3);
17. service.execute(example.new RunnableA());
18. service.execute(example.new RunnableB());
19. service.execute(example.new RunnableC());
21. service.shutdown();
22. }
24. private class RunnableA implements Runnable {
26. public void run() {
28. for (int i = 0; i < 10; i++) {
29. try {
30. semaphoresA.acquire();
31. } catch (InterruptedException e) {
32. // TODO Auto-generated catch block
33. e.printStackTrace();
34. }
35. System.out.println(String.format("第%d遍", i + 1));
36. System.out.println("A");
37. semaphoresB.release();
39. }
40. }
41. }
43. private class RunnableB implements Runnable {
45. public void run() {
47. for (int i = 0; i < 10; i++) {
48. try {
49. semaphoresB.acquire();
50. } catch (InterruptedException e) {
51. // TODO Auto-generated catch block
52. e.printStackTrace();
53. }
54. System.out.println("B");
55. semaphoresC.release();
56. }
58. }
59. }
61. private class RunnableC implements Runnable {
63. public void run() {
65. for (int i = 0; i < 10; i++) {
66. try {
67. semaphoresC.acquire();
68. } catch (InterruptedException e) {
69. // TODO Auto-generated catch block
70. e.printStackTrace();
71. }
72. System.out.println("C");
73. System.out.println();
75. semaphoresA.release();
76. }
77. }
78. }
79. }

【多线程打印abc】

推荐阅读

• 

  凉拌鸡爪——促进骨骼预防高血压
• 

  写在静心手触上海课程前
• 

  2345智能浏览器怎么更改主页 2345智能浏览器主页如何更改
• 

  原来是这些原因 为什么有时候手机收不到验证码
• 

  吃荔枝上火吗？
• 

  西门子新款冰箱系列：科技与品质的好融合，让您的厨房更智能
• 

  再见2018，活出精彩2019
• 

  清明何止雨纷纷
• 

  JS|深拷贝浅拷贝的区别（如何实现一个深拷贝？）
• 

  excel2019怎么提供声音反馈
• 

  上夜班不可以吃芒果和火龙果 芒果不能和什么一起吃
• 

  如何设置新买的服务器的映射？ 新买的服务器怎么映射
• 

  图文 虞姬是自刎还是被人杀死的，揭秘虞姬死亡的真相
• 

  三国志战略版卧薪尝胆战法攻略 S级战法卧薪尝胆简评
• 

  机动车怎么审车 机动车怎么审
• 

  边 刑法关于放行偷越国境人员法定量刑档次是怎样
• 

  mongodb的坑 mongodb凉了吗
• 

  怎么蒸豆包蒸豆包的方法 如何蒸酥皮豆包，酥皮包子的做法窍门
• 

  2023年10月份重庆多雨吗
• 

  违章代码46131是什么意思