多线程协作coding（三个独立线程按照要求打印）

    /**
     * （JAVA）有 3 个独立的线程，一个只会输出 A，一个只会输出 L，一个只会输出 I。
     * 在三个线程同时启动的情况下，请用合理的方式让他们按顺序打印 ALIALI。
     * 三个线程开始正常输出后，主线程若检测到用户任意的输入则停止三个打印线程的工
     * 作，整体退出。
     */
    static int count = 0;
    public static void main(String[] args) {

        ///定义一个ReentrantLock对象并绑定三个Condition对象，以便c1唤醒c2，c2唤醒c3，c3唤醒c1
        ReentrantLock lock = new ReentrantLock();
        // Condition实例支持与对象监视方法
        // 如果在Condition waiting或signalling方法中的任何一个被调用时不锁定此锁，则抛出IllegalMonitorStateException 。
        //当条件waiting方法被称为锁定被释放，并且在它们返回之前，锁被重新获取并且锁定保持计数恢复到当调用该方法时是什么。
        //如果一个线程是interrupted ，而等待，则等待将终止，则会抛出一个InterruptedException ，线程的中断状态将被清除。
        //等待线程以FIFO顺序发出信号。
        //从等待方法返回的线程的锁重新获取的顺序与初始获取锁的线程相同，这在默认情况下未指定，但是对于公平的锁有利于那些等待最长的线程。
        Condition condition = lock.newCondition();
        Condition condition1 = lock.newCondition();
        Condition condition2 = lock.newCondition();

        Thread A = new Thread(() -> {

            while (true) {

                    try {
                        lock.lock();
                        if (count % 3 == 0) {
                            System.out.println("A");
                            count++;
                            Thread.sleep(5000);
                            condition1.signal();
                        }else {
                            condition.await();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }
            }
        });
        System.out.println(count);
        Thread L = new Thread(() -> {
            while (true) {

                    try {
                        lock.lock();
                        if (count % 3 == 1){
                        System.out.println("L");

                        count++;
                        Thread.sleep(5000);
                        condition2.signal();
                    }else {
                            condition1.await();
                    }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }

            }
        });
        Thread I = new Thread(() -> {
            while (true) {
                    try {
                        lock.lock();
                        if (count % 3 == 2) {
                            System.out.println("I");
                            count++;
                            Thread.sleep(5000);
                            condition.signal();
                        }else {
                            condition2.await();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        lock.unlock();
                    }

            }
        });
        
        A.setDaemon(true);
        L.setDaemon(true);
        I.setDaemon(true);
        A.start();
        L.start();
        I.start();
        Scanner scanner = new Scanner(System.in);
        if(scanner.hasNext()){
            System.exit(0);
        }
    }