多线程交互

在Java中，可以使用synchronized关键字或者java.util.concurrent包中的工具来实现多线程交替打印。以下是一个使用synchronized关键字的示例：

public class AlternatePrinting {

    private static final Object lock = new Object();

    private static Integer counter = 0;

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (counter <= 10) {
                synchronized (lock) {
                    if (counter % 2 == 0) {
                        System.out.println("t1:" + counter++);
                        lock.notify();
                    } else {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }
            }
        });

        Thread t2 = new Thread(() -> {
            while (counter <= 10) {
                synchronized (lock) {
                    if (counter % 2 == 1) {
                        System.out.println("t2:" + counter++);
                        lock.notify();
                    } else {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    }
                }

            }
        });
        t1.start();
        t2.start();
    }

}

运行效果：

以下是一个使用java.util.concurrent.locks.Condition的示例：

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

public class AlternatePrinting {
    private static final Lock lock = new ReentrantLock();//定义了一个私有静态最终的`ReentrantLock`对象`lock`来实现同步

    //定义了两个`Condition`对象`condition1`和`condition2`，它们用于线程间的协调/通信。
    private static final Condition condition1 = lock.newCondition();
    private static final Condition condition2 = lock.newCondition();

    //定义了一个静态整型`counter`并初始化为1，用作计数器
    private static int counter = 1;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            while (counter <= 9) {
                lock.lock();
                try {
                    while (counter % 2 == 0) {//如果计数器为偶数，则需要等待直到`condition1`接收到信号。
                        try {
                            condition1.await();//当前线程释放锁：调用`await()`方法的线程会释放与`Condition`关联的`Lock`，允许其他线程获得这个锁并执行它们的任务。
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    //`thread1`循环执行，只有当`counter<=19`且`counter`为奇数时，才打印`counter`的值，并将`counter`增加1。
                    System.out.println("Thread 1: " + counter++);

                    //唤醒等待：如果有任何线程正在等待与 `condition2` 关联的 `Lock` 上的 `condition2.await();`，则调用 `signal()` 方法会选择其中一个线程（如果有多个线程在等待）并通知它可以继续执行
                    condition2.signal();
                } finally {
                    lock.unlock();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            while (counter <= 9) {
                lock.lock();
                try {
                    while (counter % 2 == 1) {//如果计数器为奇数，则需要等待直到`condition2`接收到信号。
                        try {
                            condition2.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    //`thread2`循环执行，只有当`counter<=19`且`counter`为偶数时，才打印`counter`的值，并将`counter`增加1。
                    System.out.println("Thread 2: " + counter++);
                    condition1.signal();
                } finally {
                    lock.unlock();
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

运行效果：

总结

在这个示例中，我们使用了ReentrantLock和两个Condition对象来实现线程的交替执行。ReentrantLock是一个可重入的互斥锁，它提供了与synchronized关键字类似的功能，但更加灵活。Condition对象用于在锁的基础上实现线程的等待和唤醒。

在这个示例中，我们创建了两个线程，它们分别打印奇数和偶数。每个线程都有一个与之关联的Condition对象。当一个线程获得锁并检查到counter的值满足条件时，它会打印counter的值并增加counter，然后调用与之关联的Condition对象的signal()方法唤醒等待的线程。如果counter的值不满足条件，线程会调用与之关联的Condition对象的await()方法进入等待状态，释放锁以便其他线程可以执行。

这个示例中的两个线程会交替打印1到10之间的奇数和偶数。这种方法使用了java.util.concurrent包中的工具，提供了更好的性能和灵活性。