三个线程交替打印ABC100次问题思考

如题：使用三个线程交替打印ABC，直至100次代码实战

方法一：

使用notify()、wait()方法

1. public class PrintAbc {
3.     /**
4.      * 唤醒线程的状态值 state: threadA = 0, threadB = 1, threadC =2,
5.      */
6.     int state = 0;
8.     /**
9.      * 循环技术，初始值0
10.      */
11.     int count = 0;
13.     public void print(PrintAbc printAbc) {
14.         Thread threadA = new Thread(() -> {
15.             extracted(printAbc, "A", 0, 1);
16.         });
18.         Thread threadB = new Thread(() -> {
19.             extracted(printAbc, "B", 1, 2);
20.         });
22.         Thread threadC = new Thread(() -> {
23.             extracted(printAbc, "C", 2, 0);
24.         });
26.         threadC.start();
27.         threadB.start();
28.         try {
29.             Thread.sleep(1000L);
30.         } catch (InterruptedException e) {
31.             throw new RuntimeException(e);
32.         }
33.         threadA.start();
34.     }
36.     /**
37.      * 交替打印abc，直至100次
38.      *
39.      * @param printAbc  锁对象
40.      * @param a         打印的字母， 对应A、B、C
41.      * @param needState 当前线程对应的state状态值
42.      * @param nextState 唤醒下一个线程所需state状态值
43.      */
44.     private void extracted(PrintAbc printAbc, String a, int needState, int nextState) {
45.         while (true) {
46.             synchronized (printAbc) {
47.                 if (count >= 100) {
48.                     break;
49.                 }
50.                 if (printAbc.count < 100 && printAbc.state == needState) {
51.                     System.out.println(a);
52.                     printAbc.state = nextState;
53.                     printAbc.count++;
54.                     printAbc.notifyAll();
55.                 } else {
56.                     try {
57.                         printAbc.wait();
58.                     } catch (InterruptedException e) {
59.                         throw new RuntimeException(e);
60.                     }
61.                 }
62.             }
63.         }
64.     }
66.     public static void main(String[] args) {
67.         PrintAbc printAbc = new PrintAbc();
68.         printAbc.print(printAbc);
69.     }
70. }

复制代码

上述代码使用notify(),wait(),进行线程间的条件唤醒，state的初始状态是0，对应线程A，所以第一次打印字母也一定是A
方法二

使用ReentrantLock的的Condition条件

1. public class PrintAbcByCondition {
3.     /**
4.      * 循环计数初始值0
5.      */
6.     static int count = 0;
8.     public void print() {
9.         ReentrantLock reentrantLock = new ReentrantLock();
10.         Condition conditionA = reentrantLock.newCondition();
11.         Condition conditionB = reentrantLock.newCondition();
12.         Condition conditionC = reentrantLock.newCondition();
13.         Thread threadA = new Thread(() -> {
14.             while (true) {
15.                 try {
16.                     reentrantLock.lock();
17.                     // threadA进来打印A然后唤醒threadB
18.                     if (count < 100) {
19.                         System.out.println("A");
20.                         count++;
21.                         conditionB.signal();
22.                     }
23.                     conditionA.await();
25.                 } catch (InterruptedException e) {
26.                     throw new RuntimeException(e);
27.                 } finally {
28.                     reentrantLock.unlock();
29.                 }
30.             }
31.         });
32.         Thread threadB = new Thread(() -> {
33.             while (true) {
34.                 try {
35.                     reentrantLock.lock();
36.                     // threadB进来就阻塞等待threadA使用完毕
37.                     conditionB.await();
38.                     if (count < 100) {
39.                         System.out.println("B");
40.                         count++;
41.                         conditionC.signal();
42.                     }
44.                 } catch (InterruptedException e) {
45.                     throw new RuntimeException(e);
46.                 } finally {
47.                     reentrantLock.unlock();
48.                 }
49.             }
50.         });
51.         Thread threadC = new Thread(() -> {
52.             while (true) {
53.                 try {
54.                     reentrantLock.lock();
55.                     // threadC进来就阻塞等待threadB使用完毕
56.                     conditionC.await();
57.                     if (count < 100) {
58.                         System.out.println("C");
59.                         count++;
60.                         conditionA.signal();
61.                     }
62.                 } catch (InterruptedException e) {
63.                     throw new RuntimeException(e);
64.                 } finally {
65.                     reentrantLock.unlock();
66.                 }
67.             }
68.         });
70.         threadC.start();
71.         threadB.start();
72.         try {
73.             Thread.sleep(1000L);
74.         } catch (InterruptedException e) {
75.             throw new RuntimeException(e);
76.         }
77.         threadA.start();
78.     }
80.     public static void main(String[] args) {
81.         new PrintAbcByCondition().print();
82.     }
83. }

复制代码

使用ReentrantLock的的Condition条件，很容易能实现三个线程之间的交替打印，需要注意的一点就是线程A是需要第一个执行，可以看到代码里threadA在等待1秒后在执行，也能确保是第一个进行打印，原因如下：

线程B和线程C中任意一个线程拿到锁都需要等待条件成立，线程C依赖线程B，而线程B依赖线程A，所以他们会一直阻塞直至线程A执行

上述两个方法中，核心问题就是如何实现线程间的条件唤醒，如方法一，我们可以自定义state状态变量来与各个线程绑定，每个线程都有自己对应的state状态，当state变量当前值与线程自身期望的state值相同才唤醒当前线程。也可以使用juc中ReentrantLock的提供的Condition条件完成线程间的条件唤醒
至此，三个线程交替打印ABC100次的实现方法介绍完毕

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