Java中的内置锁synchronized关键字和wait()、notifyAll()方法

这个问题可以通过Java中的内置锁synchronized关键字和wait()、notifyAll()方法来解决。具体的做法是这样的：

1. 创建一个共享的volatile变量count，初始值为0。
2. 在第一个线程中，循环判断count是否为0，如果是则输出A并加锁，如果不是则等待。然后输出A并将count减1，唤醒所有等待的线程。
3. 在第二个线程中，循环判断count是否为1，如果是则输出L并加锁，如果不是则等待。然后输出L并将count减1，唤醒所有等待的线程。
4. 在第三个线程中，循环判断count是否为2，如果是则输出I并加锁，如果不是则等待。然后输出I并将count减1，唤醒所有等待的线程。

这样就可以保证三个线程按顺序打印ALIALI。
以下是相关的Java代码示例：

public class PrintThread {
   
    private volatile int count = 0;

    public static void main(String[] args) {
   
        PrintThread printThread = new PrintThread();
        Thread threadA = new Thread(printThread::printA);
        Thread threadL = new Thread(printThread::printL);
        Thread threadI = new Thread(printThread::printI);

        threadA.start();
        threadL.start();
        threadI.start();

        try {
   
            threadA.join();
            threadL.join();
            threadI.join();
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
    }

    private synchronized void printA() {
   
        while (count != 0) {
   
            try {
   
                wait();
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }

        System.out.print("A");
        count--;
        notifyAll();
    }

    private synchronized void printL() {
   
        while (count != 1) {
   
            try {
   
                wait();
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }

        System.out.print("L");
        count--;
        notifyAll();
    }

    private synchronized void printI() {
   
        while (count != 2) {
   
            try {
   
                wait();
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
        }

        System.out.print("I");
        count--;
        notifyAll();
    }
}

注意，这段代码只是一个简单的示例，实际使用时需要考虑更多的细节，比如异常处理、超时控制等。