多线程面试题——交替输出问题（Java），2024年最新2024Java最新大厂面试真题总结

一定要保证交替输出，这就涉及到两个线程的同步问题。

有人可能会想到，用睡眠时间差来实现，但是只要是多线程里面，线程同步玩sleep()函数的，99.99%都是错的。

这道题其实有100多种解法。

最简单的解法

---

是这个问题的最优解，但其实不是面试官想听到的答案

关键函数

Locksupport.park()：阻塞当前线程

Locksupport.unpark("")：唤醒某个线程

LockSupport

package com.mashibing.juc.c_026_00_interview.A1B2C3

import java.util.concurrent.locks.LockSupport;

public class T02_00_LockSupport {

static Thread t1 = null, t2 = null;

public static void main(String[] args) throws Exception {

char[] aI = “1234567”.toCharArray();

char[] aC = “ABCDEFG”.toCharArray();

t1 = new Thread(() -> {

for (char c : aI) {

System.out.print©;

LockSupport.unpark(t2); // 叫醒t2

LockSupport.park(); // t1阻塞 当前线程阻塞

}

}, “t1”);

t2 = new Thread(() -> {

for (char c : aC) {

LockSupport.park(); // t2挂起

System.out.print©;

LockSupport.unpark(t1); // 叫醒t1

}

}, “t2”);

t1.start();

t2.start();

}

}

执行程序：

是我们想要的结果。

---

面试官想听到的解法

---

synchronized wait notify

package com.mashibing.juc.c_026_00_interview.A1B2C3

public class T06_00_sync_wait_notify {

public static void main(String[] args) {

final Object o = new Object();

char[] aI = “1234567”.toCharArray();

char[] aC = “ABCDEFG”.toCharArray();

new Thread(() -> {

// 首先创建一把锁

synchronized (o) {

for (char c : aI) {

System.out.print©;

try {

o.notify(); // 叫醒等待队列里面的一个线程，对本程序来说就是另一个线程

o.wait(); // 让出锁

} catch (InterruptedException e) {

e.printStackTrace();

}

}

o.notify(); // 必须，否则无法停止程序

}

}, “t1”).start();

new Thread(() -> {

synchronized (o) {

for (char c : aC) {

System.out.print©;

try {

o.notify();

o.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

o.notify();

}

}, “t2”).start();

}

}

可能有人会想，代码中的notify()和wait()顺序是不是没什么区别呢？那你就大错特错了，说明你不明白notify()和wait()是怎么执行的。

这道题其实是华为面试的填空题，让你填notify()和wait()。

如果我们先执行wait()，会先让自己直接进入等待队列，自己和另一个线程都在等待队列中等待，两个线程大👁瞪小👁，在那傻等，谁也叫不醒对方，也就是根本执行不了notify()。

我们发现，在程序的后面还有一个notify()，而且还是必须有的，为什么是必须呢？我们将它注释掉，输出一下看看

其实这是一个小坑。

虽然程序可以正常输出，但是程序没有结束；我们可以根据动图发现，最后一定是有一个线程是处在wait()状态的，没有人叫醒它，它就会永远处在等待状态中，从而程序无法结束，为了避免出现这种情况，我们要在后面加上一个notify()。

但是还有一个大坑！！！

玩过线程的应该早就发现了这个问题，如果第二个线程先抢到了，那么输出的就是A1B2C3了，怎么保证第一个永远先输出的是数字？

我们可以使用CountDownLatch这个类，它是JUC新的同步工具，这个类可以想象成一个门栓，当我们有线程执行到门这里，它会等待门栓把门打开，线程才会执行；如果t2抢先一步，那么它会执行await()方法，因为有门栓的存在，它只能在门外等待，所以t1线程会直接执行，执行到countDown()方法，使创建的CountDownLatch(1)参数置为0，即释放门栓，所以永远都是t1线程执行完，t2线程才会执行。

完整代码

package com.mashibing.juc.c_026_00_interview.A1B2C3

import java.util.concurrent.CountDownLatch;

public class T07_00_sync_wait_notify {

private static CountDownLatch latch = new CountDownLatch(1); // 设置门栓的参数为1，即只有一个门栓

public static void main(String[] args) {

final Object o = new Object();

char[] aI = “1234567”.toCharArray();

char[] aC = “ABCDEFG”.toCharArray();

new Thread(() -> {

synchronized (o) {

for (char c : aI) {

System.out.print©;

latch.countDown(); // 门栓的数值-1，即打开门

try {

o.notify();

o.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

o.notify();

}

}, “t1”).start();

new Thread(() -> {

try {

latch.await(); // 想哪个线程后执行，await()就放在哪个线程里

} catch (InterruptedException e) {

e.printStackTrace();

}

synchronized (o) {

for (char c : aC) {

System.out.print©;

try {

o.notify();

o.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

o.notify();

}

}, “t2”).start();

}

}

这样就解决了我们的担忧。

---

更灵活，更精细的解法

---

JDK提供了很多新的同步工具，在JUC包下，其中有一个专门替代synchronized的锁：Lock。

Lock ReentrantLock await signal

package com.mashibing.juc.c_026_00_interview.A1B2C3

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class T08_00_lock_condition {

public static void main(String[] args) {

char[] aI = “1234567”.toCharArray();

char[] aC = “ABCDEFG”.toCharArray();

Lock lock = new ReentrantLock();

Condition condition = lock.newCondition();

new Thread(() -> {

lock.lock();

try {

for (char c : aI) {

System.out.print©;

condition.signal(); // notify()

condition.await(); // wait()

}

condition.signal();

} catch (Exception e) {

e.printStackTrace();

} finally {

lock.unlock();

}

}, “t1”).start();

new Thread(() -> {

lock.lock(); // synchronized

try {

for (char c : aC) {

System.out.print©;

condition.signal(); // o.notify

condition.await(); // o.wait