ToB企服应用市场:ToB评测及商务社交产业平台

标题: 多线程知识：三个线程如何交替打印ABC循环100次 [打印本页]

---

作者: 民工心事    时间: 2023-7-7 17:14
标题: 多线程知识：三个线程如何交替打印ABC循环100次
本文博主给大家讲解一道网上非常经典的多线程面试题目。关于三个线程如何交替打印ABC循环100次的问题。

下文实现代码都基于Java代码在单个JVM内实现。

问题描述

给定三个线程，分别命名为A、B、C，要求这三个线程按照顺序交替打印ABC，每个字母打印100次，最终输出结果为：

1. A
2. B
3. C
4. A
5. B
6. C
7. ...
8. A
9. B
10. C

复制代码

推荐博主开源的 H5 商城项目waynboot-mall，这是一套全部开源的微商城项目，包含三个项目：运营后台、H5 商城前台和服务端接口。实现了商城所需的首页展示、商品分类、商品详情、商品 sku、分词搜索、购物车、结算下单、支付宝/微信支付、收单评论以及完善的后台管理等一系列功能。 技术上基于最新得 Springboot3.0、jdk17，整合了 MySql、Redis、RabbitMQ、ElasticSearch 等常用中间件。分模块设计、简洁易维护，欢迎大家点个 star、关注博主。
github 地址：https://github.com/wayn111/waynboot-mall

解决思路

这是一个典型的多线程同步的问题，需要保证每个线程在打印字母之前，能够判断是否轮到自己执行，以及在打印字母之后，能够通知下一个线程执行。为了实现这一目标，博主讲介绍以下5种方法：

• 使用synchronized和wait/notify
  
• 使用ReentrantLock和Condition
  
• 使用Semaphore
  
• 使用AtomicInteger和CAS
  
• 使用CyclicBarrier
  

方法一：使用synchronized和wait/notify

synchronized是Java中的一个关键字，用于实现对共享资源的互斥访问。wait和notify是Object类中的两个方法，用于实现线程间的通信。wait方法会让当前线程释放锁，并进入等待状态，直到被其他线程唤醒。notify方法会唤醒一个在同一个锁上等待的线程。
我们可以使用一个共享变量state来表示当前应该打印哪个字母，初始值为0。当state为0时，表示轮到A线程打印；当state为1时，表示轮到B线程打印；当state为2时，表示轮到C线程打印。每个线程在打印完字母后，需要将state加1，并对3取模，以便循环。同时，每个线程还需要唤醒下一个线程，并让自己进入等待状态。
具体的代码实现如下：

1. public class PrintABC {
3.     // 共享变量，表示当前应该打印哪个字母
4.     private static int state = 0;
6.     // 共享对象，作为锁和通信的媒介
7.     private static final Object lock = new Object();
9.     public static void main(String[] args) {
10.         // 创建三个线程
11.         Thread threadA = new Thread(new Runnable() {
12.             @Override
13.             public void run() {
14.                 try {
15.                     // 循环100次
16.                     for (int i = 0; i < 100; i++) {
17.                         // 获取锁
18.                         synchronized (lock) {
19.                             // 判断是否轮到自己执行
20.                             while (state % 3 != 0) {
21.                                 // 不是则等待
22.                                 lock.wait();
23.                             }
24.                             // 打印字母
25.                             System.out.println("A");
26.                             // 修改状态
27.                             state++;
28.                             // 唤醒下一个线程
29.                             lock.notifyAll();
30.                         }
31.                     }
32.                 } catch (InterruptedException e) {
33.                     e.printStackTrace();
34.                 }
35.             }
36.         });
38.         Thread threadB = new Thread(new Runnable() {
39.             @Override
40.             public void run() {
41.                 try {
42.                     for (int i = 0; i < 100; i++) {
43.                         synchronized (lock) {
44.                             while (state % 3 != 1) {
45.                                 lock.wait();
46.                             }
47.                             System.out.println("B");
48.                             state++;
49.                             lock.notifyAll();
50.                         }
51.                     }
52.                 } catch (InterruptedException e) {
53.                     e.printStackTrace();
54.                 }
55.             }
56.         });
58.         Thread threadC = new Thread(new Runnable() {
59.             @Override
60.             public void run() {
61.                 try {
62.                     for (int i = 0; i < 100; i++) {
63.                         synchronized (lock) {
64.                             while (state % 3 != 2) {
65.                                 lock.wait();
66.                             }
67.                             System.out.println("C");
68.                             state++;
69.                             lock.notifyAll();
70.                         }
71.                     }
72.                 } catch (InterruptedException e) {
73.                     e.printStackTrace();
74.                 }
75.             }
76.         });
78.         // 启动三个线程
79.         threadA.start();
80.         threadB.start();
81.         threadC.start();
82.     }
83. }

复制代码

方法二：使用ReentrantLock和Condition

ReentrantLock是Java中的一个类，用于实现可重入的互斥锁。Condition是ReentrantLock中的一个接口，用于实现线程间的条件等待和唤醒。ReentrantLock可以创建多个Condition对象，每个Condition对象可以绑定一个或多个线程，实现对不同线程的精确控制。
我们可以使用一个ReentrantLock对象作为锁，同时创建三个Condition对象，分别绑定A、B、C三个线程。每个线程在打印字母之前，需要调用对应的Condition对象的await方法，等待被唤醒。每个线程在打印字母之后，需要调用下一个Condition对象的signal方法，唤醒下一个线程。
具体的代码实现如下：

1. import java.util.concurrent.locks.Condition;
2. import java.util.concurrent.locks.ReentrantLock;
4. public class PrintABC {
6.     // 共享变量，表示当前应该打印哪个字母
7.     private static int state = 0;
9.     // 可重入锁
10.     private static final ReentrantLock lock = new ReentrantLock();
12.     // 三个条件对象，分别绑定A、B、C三个线程
13.     private static final Condition A = lock.newCondition();
14.     private static final Condition B = lock.newCondition();
15.     private static final Condition C = lock.newCondition();
17.     public static void main(String[] args) {
18.         // 创建三个线程
19.         Thread threaA = new Thread(new Runnable() {
20.             @Override
21.             public void run() {
22.                 try {
23.                     // 循环100次
24.                     for (int i = 0; i < 100; i++) {
25.                         // 获取锁
26.                         lock.lock();
27.                         try {
28.                             // 判断是否轮到自己执行
29.                             while (state % 3 != 0) {
30.                                 // 不是则等待
31.                                 A.await();
32.                             }
33.                             // 打印字母
34.                             System.out.println("A");
35.                             // 修改状态
36.                             state++;
37.                             // 唤醒下一个线程
38.                             B.signal();
39.                         } finally {
40.                             // 释放锁
41.                             lock.unlock();
42.                         }
43.                     }
44.                 } catch (InterruptedException e) {
45.                     e.printStackTrace();
46.                 }
47.             }
48.         });
50.         Thread threaB = new Thread(new Runnable() {
51.             @Override
52.             public void run() {
53.                 try {
54.                     for (int i = 0; i < 100; i++) {
55.                         lock.lock();
56.                         try {
57.                             while (state % 3 != 1) {
58.                                 B.await();
59.                             }
60.                             System.out.println("B");
61.                             state++;
62.                             C.signal();
63.                         } finally {
64.                             lock.unlock();
65.                         }
66.                     }
67.                 } catch (InterruptedException e) {
68.                     e.printStackTrace();
69.                 }
70.             }
71.         });
73.         Thread threaC = new Thread(new Runnable() {
74.             @Override
75.             public void run() {
76.                 try {
77.                     for (int i = 0; i < 100; i++) {
78.                         lock.lock();
79.                         try {
80.                             while (state % 3 != 2) {
81.                                 C.await();
82.                             }
83.                             System.out.println("C");
84.                             state++;
85.                             A.signal();
86.                         } finally {
87.                             lock.unlock();
88.                         }
89.                     }
90.                 } catch (InterruptedException e) {
91.                     e.printStackTrace();
92.                 }
93.             }
94.         });
96.         // 启动三个线程
97.         threaA.start();
98.         threaB.start();
99.         threaC.start();
100.     }
101. }

复制代码

方法三：使用Semaphore

Semaphore是Java中的一个类，用于实现信号量机制。信号量是一种计数器，用于控制对共享资源的访问。Semaphore可以创建多个信号量对象，每个信号量对象可以绑定一个或多个线程，实现对不同线程的精确控制。
我们可以使用三个Semaphore对象，分别初始化为1、0、0，表示A、B、C三个线程的初始许可数。每个线程在打印字母之前，需要调用对应的Semaphore对象的acquire方法，获取许可。每个线程在打印字母之后，需要调用下一个Semaphore对象的release方法，释放许可。
具体的代码实现如下：

1. import java.util.concurrent.Semaphore;
3. public class PrintABC {
4.     private static int state = 0;
6.     // 三个信号量对象，分别表示A、B、C三个线程的初始许可数
7.     private static final Semaphore A = new Semaphore(1);
8.     private static final Semaphore B = new Semaphore(0);
9.     private static final Semaphore C = new Semaphore(0);
11.     public static void main(String[] args) {
12.         // 创建三个线程
13.         Thread threadA = new Thread(new Runnable() {
14.             @Override
15.             public void run() {
16.                 try {
17.                     // 循环100次
18.                     for (int i = 0; i < 100; i++) {
19.                         // 获取许可
20.                         A.acquire();
21.                         // 打印字母
22.                         System.out.println("A");
23.                         // 修改状态
24.                         state++;
25.                         // 释放许可
26.                         B.release();
27.                     }
28.                 } catch (InterruptedException e) {
29.                     e.printStackTrace();
30.                 }
31.             }
32.         });
34.         Thread threadB = new Thread(new Runnable() {
35.             @Override
36.             public void run() {
37.                 try {
38.                     for (int i = 0; i < 100; i++) {
39.                         B.acquire();
40.                         System.out.println("B");
41.                         state++;
42.                         C.release();
43.                     }
44.                 } catch (InterruptedException e) {
45.                     e.printStackTrace();
46.                 }
47.             }
48.         });
50.         Thread threadC = new Thread(new Runnable() {
51.             @Override
52.             public void run() {
53.                 try {
54.                     for (int i = 0; i < 100; i++) {
55.                         C.acquire();
56.                         System.out.println("C");
57.                         state++;
58.                         A.release();
59.                     }
60.                 } catch (InterruptedException e) {
61.                     e.printStackTrace();
62.                 }
63.             }
64.         });
66.         // 启动三个线程
67.         threadA.start();
68.         threadB.start();
69.         threadC.start();
70.     }
71. }

复制代码

方法四：使用AtomicInteger和CAS

AtomicInteger是Java中的一个类，用于实现原子性的整数操作。CAS是一种无锁的算法，全称为Compare And Swap，即比较并交换。CAS操作需要三个参数：一个内存地址，一个期望值，一个新值。如果内存地址的值与期望值相等，就将其更新为新值，否则不做任何操作。
我们可以使用一个AtomicInteger对象来表示当前应该打印哪个字母，初始值为0。当state为0时，表示轮到A线程打印；当state为1时，表示轮到B线程打印；当state为2时，表示轮到C线程打印。每个线程在打印完字母后，需要使用CAS操作将state加1，并对3取模，以便循环。
具体的代码实现如下：

1. import java.util.concurrent.atomic.AtomicInteger;
3. public class PrintABC {
5.     // 共享变量，表示当前应该打印哪个字母
6.     private static AtomicInteger state = new AtomicInteger(0);
8.     public static void main(String[] args) {
9.         // 创建三个线程
10.         Thread threadA = new Thread(new Runnable() {
11.             @Override
12.             public void run() {
13.                 // 循环100次
14.                 for (int i = 0; i < 100; ) {
15.                     // 判断是否轮到自己执行
16.                     if (state.get() % 3 == 0) {
17.                         // 打印字母
18.                         System.out.println("A");
19.                         // 修改状态，使用CAS操作保证原子性
20.                         state.compareAndSet(state.get(), state.get() + 1);
21.                         // 计数器加1
22.                         i++;
23.                     }
24.                 }
25.             }
26.         });
28.         Thread threadB = new Thread(new Runnable() {
29.             @Override
30.             public void run() {
31.                 for (int i = 0; i < 100; ) {
32.                     if (state.get() % 3 == 1) {
33.                         System.out.println("B");
34.                         state.compareAndSet(state.get(), state.get() + 1);
35.                         i++;
36.                     }
37.                 }
38.             }
39.         });
41.         Thread threadC = new Thread(new Runnable() {
42.             @Override
43.             public void run() {
44.                 for (int i = 0; i < 100; ) {
45.                     if (state.get() % 3 == 2) {
46.                         System.out.println("C");
47.                         state.compareAndSet(state.get(), state.get() + 1);
48.                         i++;
49.                     }
50.                 }
51.             }
52.         });
54.         // 启动三个线程
55.         threadA.start();
56.         threadB.start();
57.         threadC.start();
58.     }
59. }

复制代码

方法五：使用CyclicBarrier

CyclicBarrier是Java中的一个类，用于实现多个线程之间的屏障。CyclicBarrier可以创建一个屏障对象，指定一个参与等待线程数和一个到达屏障点时得动作。当所有线程都到达屏障点时，会执行屏障动作，然后继续执行各自的任务。CyclicBarrier可以重复使用，即当所有线程都通过一次屏障后，可以再次等待所有线程到达下一次屏障。
我们可以使用一个CyclicBarrier对象，指定三个线程为参与等待数，以及一个打印字母的到达屏障点动作。每个线程在执行完自己的任务后，需要调用CyclicBarrier对象的await方法，等待其他线程到达屏障点。当所有线程都到达屏障点时，会执行打印字母的屏障动作，并根据state的值判断应该打印哪个字母。然后，每个线程继续执行自己的任务，直到循环结束。需要注意得就是由于打印操作在到达屏障点得动作内执行，所以三个线程得循环次数得乘以参与线程数量，也就是三。
具体的代码实现如下：

1. import java.util.concurrent.BrokenBarrierException;
2. import java.util.concurrent.CyclicBarrier;
4. public class PrintABC {
6.     // 共享变量，表示当前应该打印哪个字母
7.     private static int state = 0;
9.     // 参与线程数量
10.     private static int threadNum = 3;
12.     // 循环屏障，指定三个线程为屏障点，以及一个打印字母的屏障动作
13.     private static final CyclicBarrier barrier = new CyclicBarrier(threadNum, new Runnable() {
14.         @Override
15.         public void run() {
16.             // 根据state的值判断应该打印哪个字母
17.             switch (state) {
18.                 case 0:
19.                     System.out.println("A");
20.                     break;
21.                 case 1:
22.                     System.out.println("B");
23.                     break;
24.                 case 2:
25.                     System.out.println("C");
26.                     break;
27.             }
28.             // 修改状态
29.             state = (state + 1) % 3;
30.             System.out.println(state);
31.         }
32.     });
34.     public static void main(String[] args) {
35.         // 创建三个线程
36.         Thread threadA = new Thread(new Runnable() {
37.             @Override
38.             public void run() {
39.                 try {
40.                     // 循环100次
41.                     for (int i = 0; i < threadNum * 100; i++) {
42.                         // 执行自己的任务
43.                         // ...
44.                         // 等待其他线程到达屏障点
45.                         barrier.await();
46.                     }
47.                 } catch (InterruptedException | BrokenBarrierException e) {
48.                     e.printStackTrace();
49.                 }
50.             }
51.         });
53.         Thread threadB = new Thread(new Runnable() {
54.             @Override
55.             public void run() {
56.                 try {
57.                     for (int i = 0; i < threadNum * 100; i++) {
58.                         // 执行自己的任务
59.                         // ...
60.                         // 等待其他线程到达屏障点
61.                         barrier.await();
62.                     }
63.                 } catch (InterruptedException | BrokenBarrierException e) {
64.                     e.printStackTrace();
65.                 }
66.             }
67.         });
69.         Thread threadC = new Thread(new Runnable() {
70.             @Override
71.             public void run() {
72.                 try {
73.                     for (int i = 0; i < threadNum * 100; i++) {
74.                         // 执行自己的任务
75.                         // ...
76.                         // 等待其他线程到达屏障点
77.                         barrier.await();
78.                     }
79.                 } catch (InterruptedException | BrokenBarrierException e) {
80.                     e.printStackTrace();
81.                 }
82.             }
83.         });
85.         // 启动三个线程
86.         threadA.start();
87.         threadB.start();
88.         threadC.start();
89.     }
90. }

复制代码

总结

到此，本文内容已经讲解完毕，以上的这五种方法都可以利用不同的工具和机制来实现多线程之间的同步和通信，从而保证按照顺序交替打印ABC。这些方法各有优缺点，具体的选择需要根据实际的场景和需求来决定。
最后本文讲解代码是在单个JVM内的实现方法，如果大家对涉及到多个JVM来实现按照顺序交替打印ABC的话，可以私信博主，博主再给大家出一期文章进行讲解。

关注公众号【waynblog】每周分享技术干货、开源项目、实战经验、高效开发工具等，您的关注将是我的更新动力！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4