Java 交替打印两个线程的三儿种方法

<think>嗯，用户想了解如何用Java实现两个线程交替打印奇偶数。这个问题听起来像是多线程编程中的经典问题，主要考察线程间的同步和通信。我需要先回忆一下相关的知识，然后一步步构建解决方案。 首先，我得明确需求：两个线程，一个打印奇数，另一个打印偶数，交替执行。比如，线程A打印1，线程B打印2，接着线程A打印3，线程B打印4，依此类推。关键点在于如何让两个线程在正确的时候等待和唤醒，确保顺序正确。 Java中实现线程同步通常用synchronized关键字配合wait()和notify()方法，或者使用Lock和Condition。可能用户需要的是基础的实现方式，所以先用synchronized的方式来说明。不过，也要考虑是否有更高效的方法，比如使用重入锁。 接下来，我需要考虑如何共享状态。两个线程需要有一个共同的变量来记录当前的数值，并且判断是奇数还是偶数。这个变量需要被两个线程访问，所以必须是线程安全的。不过，在同步块内部操作的话，可以保证原子性，所以用普通的int变量应该足够。 步骤大概是这样的：创建一个共享对象作为锁，一个计数器从1开始。奇数线程在计数器为奇数时打印，然后递增，并通知偶数线程。偶数线程则等待，直到计数器变为偶数时打印，递增，再通知奇数线程。但这里可能有个问题，因为初始时计数器是1，奇数线程先执行，打印后变成2，然后偶数线程唤醒，打印2之后变成3，这样交替下去。但需要确保每个线程只在符合自己条件的时候执行，否则会出现错误的打印。 或者，另一种思路是使用两个线程交替获取锁，每次打印后释放锁，让另一个线程运行。这里可能需要一个标志位，指示当前该哪个线程执行。例如，一个布尔变量isOdd，当为true时，奇数线程执行，打印后设置为false，并唤醒另一个线程；偶数线程则等待直到isOdd为false。这样交替切换标志位，确保顺序正确。 然后，我需要考虑如何编写具体的代码结构。比如，定义一个Runnable接口的实现，或者直接创建两个Thread子类。通常，使用Runnable更灵活，因为可以共享资源。 可能的代码结构如下： - 共享对象：包含一个计数器num和一个锁对象（或者直接用this）。 - 奇数线程：循环检查num是否为奇数，如果是则打印，然后递增，并通知另一个线程。 - 偶数线程：同样循环检查num是否为偶数，打印并递增，通知对方。 但是，这样的检查必须放在同步块中，否则会有竞态条件。而且，需要使用while循环来避免虚假唤醒，即当线程被唤醒后，再次检查条件是否满足，如果不满足，继续等待。 例如，奇数线程的代码大致如下： synchronized (lock) { while (num <= max) { if (num % 2 == 1) { System.out.println(...); num++; lock.notify(); } else { lock.wait(); } } } 同样，偶数线程的条件是num % 2 ==0。但这样可能存在一个问题，比如当num超过max时，两个线程都需要退出循环。不过，循环条件已经限制了num <= max，所以当超过max时，线程会自然退出。 另一个问题是，这样的结构是否会导致两个线程交替执行。比如，当奇数线程打印后，递增num，然后调用notify()，此时可能唤醒偶数线程。偶数线程检查num是否为偶数，如果是，打印，递增，然后唤醒奇数线程。这样循环下去直到达到max。 但需要确保两个线程的启动顺序，即先启动奇数线程还是偶数线程。如果初始num是1，那么奇数线程会先执行，然后偶数线程被唤醒。但是如果两个线程同时启动，可能出现竞争。例如，偶数线程启动后，发现num是1，进入等待，而奇数线程执行。这样是正确的。所以启动顺序可能不影响，因为即使偶数线程先运行，也会进入等待状态，直到奇数线程修改num并通知。 不过，实际测试中可能会发现，有时候其中一个线程会先获取锁，导致另一个线程必须等待。所以，在代码中可能需要确保初始时奇数线程先执行。或者，让两个线程在启动时都能处理这种情况。 另一个可能的优化是，使用一个共享的锁，并且用一个布尔变量来指示当前应该由哪个线程执行。例如，当应该打印奇数时，奇数线程执行，否则等待；偶数线程同理。这样可以减少不必要的检查。例如： synchronized (lock) { while (num <= max) { while (!turn) { // turn为true表示该奇数线程执行 lock.wait(); } System.out.println(...); num++; turn = false; lock.notify(); } } 而偶数线程则检查turn是否为false。这种方式可能更直接地控制交替过程，但需要处理初始状态。比如，初始时turn为true，让奇数线程先执行。 不过，这样可能需要两个不同的Runnable，或者根据turn的值在同一个Runnable中判断。或者，可以将判断逻辑放在各自的线程中。例如，奇数线程只处理当turn为true时的操作，而偶数线程处理turn为false的情况。 不过，这样的设计可能需要更多的代码，但结构更清晰。或者，可以将两个线程的逻辑合并到一个类中，根据传入的参数来决定是奇数还是偶数线程。这可能更高效，减少重复代码。 总结一下，可能的实现步骤： 1. 创建一个共享对象作为锁，包含当前的数值num和最大值max。 2. 创建两个线程，一个负责奇数，一个负责偶数。 3. 每个线程在循环中获取锁，检查当前num是否超过max，如果超过则退出。 4. 检查当前是否应该由自己打印（即num是奇数还是偶数）。 5. 如果是，则打印并递增num，然后唤醒另一个线程。 6. 如果不是，则等待，直到被另一个线程唤醒。 7. 循环直到num超过max。 现在，编写具体的代码示例。例如： public class OddEvenPrinter { private static final int MAX = 10; private static int num = 1; private static final Object lock = new Object(); public static void main(String[] args) { Thread oddThread = new Thread(() -> { while (num <= MAX) { synchronized (lock) { while (num % 2 == 0) { // 如果是偶数，等待 try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } if (num > MAX) { break; } System.out.println("奇数线程：" + num); num++; lock.notifyAll(); } } }); Thread evenThread = new Thread(() -> { while (num <= MAX) { synchronized (lock) { while (num % 2 == 1) { // 如果是奇数，等待 try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } if (num > MAX) { break; } System.out.println("偶数线程：" + num); num++; lock.notifyAll(); } } }); oddThread.start(); evenThread.start(); } } 不过，这段代码可能存在一个问题：当num在进入synchronized块之前被另一个线程修改，导致循环条件不准确。例如，当num已经超过MAX，但线程已经进入了循环，此时可能还会执行打印。因此，在synchronized块内部需要再次检查num是否超过MAX。 或者，将整个循环放在synchronized块内部，但这会影响性能，因为线程会一直持有锁。因此，更合理的方式是在同步块内部进行检查。 另外，使用notifyAll()而不是notify()，因为可能有多个线程在等待，但在这个案例中只有两个线程，所以notify()也足够。不过，为了安全起见，使用notifyAll()更稳妥。 另一个需要注意的地方是，当线程被唤醒后，必须重新检查条件，因为可能发生虚假唤醒，或者在被阻塞期间条件已经改变。 例如，在奇数线程中，当num变为偶数时，会唤醒偶数线程。但如果在notify之后，num又被其他线程修改，可能会导致问题，但由于在同步块中，其他线程无法同时修改，所以应该没问题。 但是，上面的代码中，每个线程在进入同步块后，首先检查num的奇偶性。如果不符合自己的条件，就进入等待。当被唤醒后，再次检查条件。这样确保了只有在条件满足时才会执行打印。 测试这个代码，当MAX=10时，应该输出1到10，交替由奇偶线程打印。但需要确保在打印到MAX后，两个线程都能正确退出。 例如，当num=10时，偶数线程打印10，然后num++变为11。此时，两个线程在进入循环时，判断num <= MAX（MAX=10）为false，因此退出循环，线程结束。 但可能存在这样的情况：当奇数线程在打印完9之后，num变为10，然后唤醒偶数线程。偶数线程进入同步块，检查num是偶数，打印10，num变为11，然后唤醒奇数线程。此时，奇数线程再次进入循环，发现num=11 > MAX=10，退出循环。 同样，当num=11时，两个线程的while循环条件都不满足，线程结束。 所以，这样的代码应该是正确的。 不过，可能还有一种情况，当MAX是一个较大的数时，两个线程交替执行的效率如何？例如，每次打印后都会释放锁，让另一个线程获取锁。这应该没问题，因为每次操作后都会通知对方线程。 另一种实现方式是使用两个不同的Runnable，或者使用一个共享的变量来控制交替。比如，使用一个布尔变量isOddTurn，初始为true。奇数线程在isOddTurn为true时执行，打印后设置为false，并唤醒另一个线程；偶数线程则在isOddTurn为false时执行，打印后设置为true。 这种方式可能更直观，因为它直接控制了线程的交替，而不是依赖于数值的奇偶性。例如： public class OddEvenPrinter2 { private static int num = 1; private static final int MAX = 10; private static final Object lock = new Object(); private static boolean isOddTurn = true; public static void main(String[] args) { Thread oddThread = new Thread(() -> { while (num <= MAX) { synchronized (lock) { while (!isOddTurn) { try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } if (num > MAX) break; System.out.println("奇数线程：" + num); num++; isOddTurn = false; lock.notify(); } } }); Thread evenThread = new Thread(() -> { while (num <= MAX) { synchronized (lock) { while (isOddTurn) { try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } if (num > MAX) break; System.out.println("偶数线程：" + num); num++; isOddTurn = true; lock.notify(); } } }); oddThread.start(); evenThread.start(); } } 这种方法可能更容易理解，因为直接通过标志位控制交替，而不是依赖数值本身的奇偶性。例如，当isOddTurn为true时，只有奇数线程可以执行，打印后设置为false，唤醒偶数线程。这样可以避免每次都要计算num的奇偶性，尤其是当数值很大时，可能更高效。 不过，两种方法在功能上都是可行的，选择哪种取决于具体需求。用户可能需要了解这两种方法的区别，或者其中一种更优的情况。 另外，需要注意线程启动的顺序。例如，如果先启动evenThread，但由于初始isOddTurn为true，它会立即进入等待状态，所以不会影响结果。 测试这两种实现方式，应该都能正确交替打印奇偶数。不过，第一种方法依赖于数值本身的奇偶性，而第二种方法通过标志位控制，可能在代码结构上更清晰。 最后，还需要考虑可能的异常处理，比如InterruptedException，但在这个简单的例子中可能不需要复杂的处理，只是打印堆栈跟踪。 总结，用户的问题可以通过使用synchronized块结合wait()和notify()方法来实现，关键在于正确地在同步块中检查条件，并使用循环来防止虚假唤醒。两种方法都可以达到目的，选择哪一种取决于具体需求和代码风格的偏好。</think>以下是Java实现两个线程交替打印奇偶数的详细步骤： ### 一、实现原理 1. **同步控制**：使用`synchronized`保证线程互斥访问 2. **通信机制**：通过`wait()`和`notify()`实现线程间通信 3. **状态判断**：通过数值奇偶性决定线程执行权 ### 二、基础实现代码 ```java public class OddEvenPrinter { private static int num = 1; private static final int MAX = 10; private static final Object lock = new Object(); public static void main(String[] args) { // 奇数线程 new Thread(() -> { while (num <= MAX) { synchronized (lock) { while (num % 2 == 0) { // 不是奇数时等待 try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } if (num > MAX) return; System.out.println("奇数线程：" + num++); lock.notify(); // 唤醒偶数线程 } } }).start(); // 偶数线程 new Thread(() -> { while (num <= MAX) { synchronized (lock) { while (num % 2 == 1) { // 不是偶数时等待 try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } if (num > MAX) return; System.out.println("偶数线程：" + num++); lock.notify(); // 唤醒奇数线程 } } }).start(); } } ``` ### 三、代码解析 1. **共享资源**： - `num`：当前要打印的数值 - `lock`：作为同步锁对象 2. **线程工作逻辑**： ```mermaid graph TD A[奇数线程启动] --> B{num ≤ MAX?} B -->|是| C[获取锁] C --> D{是奇数?} D -->|否| E[等待] D -->|是| F[打印并递增] F --> G[唤醒其他线程] G --> H[释放锁] B -->|否| I[结束] ``` 3. **关键点**： - 使用`while`循环防止虚假唤醒 - 每次操作后必须释放锁 - 通知机制确保交替执行 ### 四、优化方案（使用标志位） ```java public class OptimizedPrinter { private static int num = 1; private static final int MAX = 10; private static final Object lock = new Object(); private static boolean isOddTurn = true; public static void main(String[] args) { new Thread(() -> { while (num <= MAX) { synchronized (lock) { while (!isOddTurn) { try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } if (num > MAX) return; System.out.println("优化-奇数线程：" + num++); isOddTurn = false; lock.notify(); } } }).start(); new Thread(() -> { while (num <= MAX) { synchronized (lock) { while (isOddTurn) { try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } if (num > MAX) return; System.out.println("优化-偶数线程：" + num++); isOddTurn = true; lock.notify(); } } }).start(); } } ``` ### 五、两种方案对比 | 特性 | 基础方案 | 优化方案 | |------------------|------------------------|------------------------| | 判断条件 | 数值奇偶性 | 布尔标志位 | | 计算开销 | 每次计算取模运算 | 直接判断布尔值 | | 可扩展性 | 适合简单交替 | 方便扩展多线程交替 | | 逻辑直观性 | 直接反映问题需求 | 需要维护额外状态 | ### 六、注意事项 1. 必须使用`while`循环检查条件，不能改用`if` 2. 确保在修改共享变量后调用`notify()` 3. 注意数值溢出问题（本例中MAX=10不存在此问题） 4. 线程启动顺序不影响最终结果 ### 七、执行结果示例 ``` 奇数线程：1 偶数线程：2 奇数线程：3 偶数线程：4 ... 奇数线程：9 偶数线程：10 ``` 通过这种实现方式，可以确保两个线程严格按照奇偶交替的顺序打印数字，且不会出现竞态条件或死锁问题。实际开发中可根据具体需求选择基础方案或优化方案。