多线程交替顺序打印ABC的多种方式

口试题：有 3 个独立的线程，一个只会输出 A，一个只会输出 B，一个只会输出 C，在三个线程启动的情况下，请用合理的方式让他们按顺序打印 ABC。
使用lock，Condition

1. import java.util.concurrent.locks.Condition;
2. import java.util.concurrent.locks.Lock;
3. import java.util.concurrent.locks.ReentrantLock;
5. public class ABC {
7.     //可重入锁
8.     private final static Lock lock = new ReentrantLock();
9.     //判断是否执行：1表示应该A执行，2表示应该B执行，3表示应该C执行
10.     private static int state = 1;
11.     //condition对象
12.     private static Condition a = lock.newCondition();
13.     private static Condition b = lock.newCondition();
14.     private static Condition c = lock.newCondition();
16.     public static void printA() {
17.         //通过循环，hang住线程
18.         for (int i = 0; i < 10; i++) {
19.             try {
20.                 //获取锁
21.                 lock.lock();
22.                 //并发情况下，不能用if，要用循环判断等待条件，避免虚假唤醒
23.                 while (state != 1) {
24.                     a.await();
25.                 }
26.                 System.out.print("A");
27.                 state = 2;
28.                 b.signal();
29.             } catch (InterruptedException e) {
30.                 e.printStackTrace();
31.             } finally {
32.                 //要保证不执行的时候，锁能释放掉
33.                 lock.unlock();
34.             }
35.         }
36.     }
38.     public static void printB() throws InterruptedException {
39.         for (int i = 0; i < 10; i++) {
40.             try {
41.                 lock.lock();
42.                 //获取到锁，应该执行
43.                 while (state != 2) {
44.                     b.await();
45.                 }
46.                 System.out.print("B");
47.                 state = 3;
48.                 c.signal();
49.             } finally {
50.                 lock.unlock();
51.             }
52.         }
53.     }
55.     public static void printC() throws InterruptedException {
56.         for (int i = 0; i < 10; i++) {
57.             try {
58.                 lock.lock();
59.                 while (state != 3) {
60.                     c.await();
61.                 }
62.                 //获取到锁，应该执行
63.                 System.out.print("C");
64.                 state = 1;
65.                 a.signal();
66.             } finally {
67.                 lock.unlock();
68.             }
69.         }
70.     }
73.     public static void main(String[] args) {
74.         new Thread(new Runnable() {
75.             @Override
76.             public void run() {
77.                 ABC.printA();
78.             }
79.         }, "A").start();
81.         new Thread(new Runnable() {
82.             @Override
83.             public void run() {
84.                 try {
85.                     ABC.printB();
86.                 } catch (InterruptedException e) {
87.                     e.printStackTrace();
88.                 }
89.             }
90.         }, "B").start();
92.         new Thread(new Runnable() {
93.             @Override
94.             public void run() {
95.                 try {
96.                     ABC.printC();
97.                 } catch (InterruptedException e) {
98.                     e.printStackTrace();
99.                 }
100.             }
101.         }, "C").start();
102.     }
104. }

复制代码

使用AtomicInteger

1. import java.util.concurrent.atomic.AtomicInteger;
3. public class ABC2 {
4.     private static AtomicInteger state = new AtomicInteger(1);
6.     public static void printA() {
7.         for (int i = 0; i < 10; i++) {
8.             while (true) {
9.                 if (state.get() == 1) {
10.                     System.out.print("A");
11.                     state.incrementAndGet();
12.                     break;
13.                 }
14.             }
15.         }
16.     }
18.     public static void printB() {
19.         for (int i = 0; i < 10; i++) {
20.             while (true) {
21.                 if (state.get() == 2) {
22.                     System.out.print("B");
23.                     state.incrementAndGet();
24.                     break;
25.                 }
26.             }
27.         }
28.     }
30.     public static void printC() {
31.         for (int i = 0; i < 10; i++) {
32.             while (true) {
33.                 if (state.get() == 3) {
34.                     System.out.print("C");
35.                     state.set(1);
36.                     break;
37.                 }
38.             }
39.         }
40.     }
42.     public static void main(String[] args) {
43.         new Thread(new Runnable() {
44.             @Override
45.             public void run() {
46.                 ABC2.printA();
47.             }
48.         }, "A").start();
50.         new Thread(new Runnable() {
51.             @Override
52.             public void run() {
53.                 ABC2.printB();
54.             }
55.         }, "B").start();
57.         new Thread(new Runnable() {
58.             @Override
59.             public void run() {
60.                 ABC2.printC();
61.             }
62.         }, "C").start();
63.     }
65. }

复制代码

使用LockSupprt

线程阻塞叫醒类-LockSupport详解

1. public class ABC3 {
2.     private static Thread t1, t2, t3;
4.     public static void main(String[] args) {
5.         t1 = new Thread(() -> {
6.             for (int i = 0; i < 2; i++) {
7.                 LockSupport.park();
8.                 System.out.print("A");
9.                 LockSupport.unpark(t2);
10.             }
11.         });
13.         t2 = new Thread(() -> {
14.             for (int i = 0; i < 2; i++) {
15.                 LockSupport.park();
16.                 System.out.print("B");
17.                 LockSupport.unpark(t3);
18.             }
19.         });
21.         t3 = new Thread(() -> {
22.             for (int i = 0; i < 2; i++) {
23.                 LockSupport.park();
24.                 System.out.print("C");
25.                 LockSupport.unpark(t1);
26.             }
27.         });
29.         t1.start();
30.         t2.start();
31.         t3.start();
33.         // 主线程稍微等待一下，确保其他线程已经启动并且进入park状态。
34.         try {
35.             Thread.sleep(100);
36.         } catch (InterruptedException e) {
37.             e.printStackTrace();
38.         }
40.         // 启动整个流程
41.         LockSupport.unpark(t1);
42.     }
43. }

复制代码

口试题专栏

Java口试题专栏已上线，接待访问。

• 如果你不知道简历怎么写，简历项目不知道怎么包装；
  
• 如果简历中有些内容你不知道该不该写上去；
  
• 如果有些综合性题目你不知道怎么答；
  

那么可以私信我，我会尽我所能帮助你。
关于作者

来自一线程序员Seven的探索与实践，持续学习迭代中~
本文已收录于我的个人博客：https://www.seven97.top
公众号：seven97，接待关注~

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。