三种实现多线程交替打印 ABC 的方法，纯干货！

在多线程编程中，实现交替打印不同字符是一个常见的任务。以下将为您介绍三种实现多线程交替打印 ABC 的有效方法。

方法一：使用线程同步机制

通过使用线程同步的方式，例如互斥锁或条件变量，可以确保线程之间的协调和有序执行。首先创建三个线程，分别负责打印 A、B、C。然后，在打印操作前获取同步锁，打印完成后释放锁，以保证交替打印的正确性。

示例代码如下：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class AlternatePrinting {
    private static Lock lock = new ReentrantLock();
    private static Condition condition = lock.newCondition();
    private static char currentChar = 'A';

    public static void main(String[] args) {
        new Thread(() -> printChar('A')).start();
        new Thread(() -> printChar('B')).start();
        new Thread(() -> printChar('C')).start();
    }

    public static void printChar(char targetChar) {
        while (true) {
            lock.lock();
            try {
                while (currentChar!= targetChar) {
                    condition.await();
                }
                System.out.print(targetChar);
                currentChar = (char) ((currentChar - 'A' + 1) % 3 + 'A');
                condition.signalAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

方法二：使用线程阻塞队列

可以利用阻塞队列来实现线程之间的通信和协调。创建一个阻塞队列，将打印任务放入队列中，线程从队列中获取任务并执行打印。

以下是示例代码：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class AlternatePrintingWithQueue {

    private static BlockingQueue<Character> queue = new LinkedBlockingQueue<>();

    public static void main(String[] args) {
        queue.offer('A');
        queue.offer('B');
        queue.offer('C');

        new Thread(() -> printFromQueue()).start();
        new Thread(() -> printFromQueue()).start();
        new Thread(() -> printFromQueue()).start();
    }

    public static void printFromQueue() {
        while (true) {
            try {
                char c = queue.take();
                System.out.print(c);
                queue.offer((char) ((c - 'A' + 1) % 3 + 'A'));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

方法三：使用线程池和并发工具类

借助线程池和并发工具类，如 Semaphore ，可以更高效地管理线程资源和实现交替打印。

示例代码如下：

import java.util.concurrent.Semaphore;

public class AlternatePrintingWithThreadPool {

    private static Semaphore semaphoreA = new Semaphore(1);
    private static Semaphore semaphoreB = new Semaphore(0);
    private static Semaphore semaphoreC = new Semaphore(0);

    public static void main(String[] args) {
        // 创建线程池
        // 提交打印任务
    }

    public static void printA() {
        try {
            semaphoreA.acquire();
            System.out.print('A');
            semaphoreB.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void printB() {
        try {
            semaphoreB.acquire();
            System.out.print('B');
            semaphoreC.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void printC() {
        try {
            semaphoreC.acquire();
            System.out.print('C');
            semaphoreA.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

以上三种方法都能有效地实现多线程交替打印 ABC ，您可以根据实际需求选择适合的方法。希望这些方法对您的多线程编程有所帮助！