三个线程交替打印A，B，C_三个线程交替打印adc-优快云博客

本文链接：https://blog.youkuaiyun.com/DataIntel_XiAn/article/details/104336906

这篇博客展示了如何使用Java的多线程实现三个线程交替打印字母A、B和C。通过代码实现，线程间协作使得输出按预期顺序进行。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

代码实现：

package thread;

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;

/**
 * @ClassName: ThreadCommunication
 * @Description: 三个线程交替打印A，B，C
 * @Author: xuezhouyi
 * @Version: V1.0
 **/
public class ThreadCommunication {
    //线程标识
    private Integer no = 0;
    private Lock lock = new ReentrantLock();

    //三个线程通信
    Condition condition0 = lock.newCondition();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();

    /**
     * 打印A
     */
    public void printA() {
        lock.lock();
        try {
            //非0线程则等待
            if (no != 0) {
                condition0.await();
            }

            //打印A
            System.out.println(Thread.currentThread().getName() + ":A");

            //唤醒1线程
            no = 1;
            condition1.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 打印B
     */
    public void printB() {
        lock.lock();
        try {
            //非1线程则等待
            if (no != 1) {
                condition1.await();
            }

            //打印B
            System.out.println(Thread.currentThread().getName() + ":B");

            //唤醒2线程
            no = 2;
            condition2.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 打印C
     */
    public void printC() {
        lock.lock();
        try {
            //非2线程则等待
            if (no != 2) {
                condition2.await();
            }

            //打印C
            System.out.println(Thread.currentThread().getName() + ":C");

            //唤醒0线程
            no = 0;
            condition0.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    /**
     * Test
     */
    private static class Test {
        public static void main(String[] args) {
            final ThreadCommunication tc = new ThreadCommunication();
            final ExecutorService pool = Executors.newFixedThreadPool(3);

            //启动三个线程测试
            pool.submit(() -> {
                for (int j = 0; j < 3; j++) {
                    tc.printA();
                }
            });
            pool.submit(() -> {
                for (int j = 0; j < 3; j++) {
                    tc.printB();
                }
            });
            pool.submit(() -> {
                for (int j = 0; j < 3; j++) {
                    tc.printC();
                }
            });

            pool.shutdown();
        }
    }
}

运行结果：

pool-1-thread-1:A
pool-1-thread-2:B
pool-1-thread-3:C
pool-1-thread-1:A
pool-1-thread-2:B
pool-1-thread-3:C
pool-1-thread-1:A
pool-1-thread-2:B
pool-1-thread-3:C