java多线程实现有序输出ABC

要实现有序输出ABC，可以通过以下几种方式实现：

方式一：使用synchronized关键词

在Java中，synchronized关键字可以锁住对象，只允许一个线程访问同一时间内执行的代码块。我们可以使用该关键字来实现对三个线程输出ABC顺序的控制。

public class ABCPrinter implements Runnable {
    private char ch;
    private Object prev;
    private Object self;

    public ABCPrinter(char ch, Object prev, Object self) {
        this.ch = ch;
        this.prev = prev;
        this.self = self;
    }

    public void run() {
        synchronized (prev) {
            while (true) {
                synchronized (self) {
                    System.out.print(ch);
                    self.notify();
                }
                try {
                    prev.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Object a = new Object();
        Object b = new Object();
        Object c = new Object();
        ABCPrinter pa = new ABCPrinter('A', c, a);
        ABCPrinter pb = new ABCPrinter('B', a, b);
        ABCPrinter pc = new ABCPrinter('C', b, c);

        new Thread(pa).start();
        Thread.sleep(10);//保证初始ABC的启动顺序
        new Thread(pb).start();
        Thread.sleep(10);//保证初始ABC的启动顺序
        new Thread(pc).start();
        Thread.sleep(10);//保证初始ABC的启动顺序
    }
}

• 首先，我们定义了一个类 ABCPrinter，实现了 Runnable 接口，线程对象可以通过该接口创建。
• 这个类包含了两个 Object 对象，prev 和 self。prev 存储前一个线程的锁对象，self 存储当前线程的锁对象。
• 在 run() 方法中，我们使用 synchronized(prev) 进入同步锁，如果当前线程不符合执行条件，就让它 wait()，否则就在 synchronized(self) 代码块中输出字符，并通过 self.notify() 唤醒其他等待线程。
• 此外，我们还在 main 方法中分别启动了三个线程。在每个线程启动前都让程序 sleep 一段时间，保证启动顺序为 ABC。

方式二：使用Lock与Condition

在Java中，Lock与Condition可以实现与synchronized关键词类似的线程同步功能。我们可以使用Lock与Condition来实现多线程的有序输出ABC。

public class ABCPrinter {
    private Lock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();
    private Condition conditionC = lock.newCondition();

    private int currentThread = 0;

    public void printA() throws InterruptedException {
        lock.lock();
        try {
            while (currentThread != 0) {
                conditionA.await();
            }
            System.out.print("A");
            currentThread = 1;
            conditionB.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void printB() throws InterruptedException {
        lock.lock();
        try {
            while (currentThread != 1) {
                conditionB.await();
            }
            System.out.print("B");
            currentThread = 2;
            conditionC.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void printC() throws InterruptedException {
        lock.lock();
        try {
            while (currentThread != 2) {
                conditionC.await();
            }
            System.out.print("C");
            currentThread = 0;
            conditionA.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        final ABCPrinter printer = new ABCPrinter();

        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    printer.printA();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    printer.printB();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    printer.printC();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

• 首先，我们定义了一个类 ABCPrinter，该类包含了Lock与Condition对象，用于实现线程同步。
• ABCPrinter 类还包含了一个 currentThread 状态变量，表示上一个输出的字符。
• 在 printA、printB、printC 方法中，我们获取锁，如果当前线程不符合执行条件，就调用 await() 方法，让线程进入休眠状态。否则输出字符，并修改 currentThread 状态变量，最后调用 signalAll() 方法，唤醒其他等待线程。

以上就是两种实现多线程有序输出ABC的解决方案。可以根据实际需要来选择适合自己的方式。