在多线程的面试中,经常会遇到三个类似的线程执行问题: Q1:有 A、B、C 三个线程,如何保证三个线程同时执行? Q2:有 A、B、C 三个线程,在并发情况下,如何保证三个线程依次执行? Q3:有 A、B、C 三个线程,如何保证三个线程有序交错执行?
保证线程同时执行可以用于并发测试。可以使用倒计时锁CountDownLatch实现让三个线程同时执行。代码如下所示:
ExecutorService executorService = Executors.newCachedThreadPool();
CountDownLatch countDownLatch = new CountDownLatch(1);
executorService.submit(()->{
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程A执行,执行时间:" + System.currentTimeMillis());
});
executorService.submit(()->{
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程B执行,执行时间:" + System.currentTimeMillis());
});
executorService.submit(()->{
try {
countDownLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程C执行,执行时间:" + System.currentTimeMillis());
});
countDownLatch.countDown();
打印内容如下,通过时间可以证明三个线程是同时执行的。
线程A执行,执行时间:1617811258309
线程C执行,执行时间:1617811258309
线程B执行,执行时间:1617811258309
让三个线程同时执行,也可以使用栅栏 CyvlivBarrier 来实现,当三个线程都到达栅栏处,才开始执行。
使用 join() 方法可以保证线程的顺序执行。在 Java 中,join() 方法是用来等待一个线程执行完成的方法,当调用某个线程的 join() 方法时,当前线程会被阻塞,直到该线程执行完成后才会继续执行。
具体来说,我们可以在 T1 线程结束时调用 T2 的 join() 方法,这样 T2 就会等待 T1 执行完成后再开始执行;同理,在 T2 结束时调用 T3 的 join() 方法,以确保 T3 在 T2 执行完成后才开始执行。这样就可以保证 T1、T2、T3 按照顺序依次执行。
使用 CountDownLatch(闭锁)方法可以保证线程的顺序执行。CountDownLatch 是一个同步工具类,它可以让某个线程等待多个线程完成各自的工作之后再继续执行。
@Test
public void testUseCountDownLatch() {
ExecutorService executorService = Executors.newCachedThreadPool();
CountDownLatch aLatch = new CountDownLatch(1);
CountDownLatch bLatch = new CountDownLatch(1);
CountDownLatch cLatch = new CountDownLatch(1);
executorService.submit(() -> {
try {
aLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i < 10; i++) {
System.out.println("A - " + i);
}
bLatch.countDown();
});
executorService.submit(() -> {
try {
bLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i < 10; i++) {
System.out.println("B - " + i);
}
cLatch.countDown();
});
executorService.submit(() -> {
try {
cLatch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int i = 0; i < 10; i++) {
System.out.println("C - " + i);
}
});
aLatch.countDown();
}
执行结果:
A - 0
A - 1
A - 2
A - 3
A - 4
B - 0
B - 1
B - 2
B - 3
B - 4
C - 0
C - 1
C - 2
C - 3
C - 4
private volatile int count = 0;
/**
* 使用一个变量进行判断执行哪个线程。没有轮到的线程在不停循环,没有停止线程
*/
public void useVolatile() {
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.submit(() -> {
while (true) {
if (count == 0) {
for (int i = 0; i < 5; i++) {
System.out.println("A - " + i);
}
count = 1;
break;
}
}
});
executorService.submit(() -> {
while (true) {
if (count == 1) {
for (int i = 0; i < 5; i++) {
System.out.println("B - " + i);
}
count = 2;
break;
}
}
});
executorService.submit(() -> {
while (true) {
if (count == 2) {
for (int i = 0; i < 5; i++) {
System.out.println("C - " + i);
}
count = 3;
break;
}
}
});
}
使用单个线程池可以保证t1、t2、t3顺序执行,因为单个线程池只有一个工作线程,每次只会执行一个任务。我们可以将t1、t2、t3三个任务按照顺序提交给单个线程池,这样就可以确保它们按照顺序依次执行。
实现三个线程交错打印,可以使用ReentrantLock以及3个Condition来实现,代码如下所示:
package com.wangguitang.freedom.interview.concurrent;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
public class ThreeThreadsAlternatePrint {
private static final ReentrantLock lock = new ReentrantLock();
private static Condition c1 = lock.newCondition();
private static Condition c2 = lock.newCondition();
private static Condition c3 = lock.newCondition();
public static void main(String[] args) {
new Thread(() -> {
try {
lock.lock();
for (int i = 0; i < 10; i++) {
System.out.println("A - " + i);
c2.signal();
c1.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}).start();
new Thread(() -> {
try {
lock.lock();
for (int i = 0; i < 10; i++) {
System.out.println("B - " + i);
c3.signal();
c2.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}).start();
new Thread(() -> {
try {
lock.lock();
for (int i = 0; i < 10; i++) {
System.out.println("C - " + i);
c1.signal();
c3.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}).start();
}
}
执行结果:
A - 0
B - 0
C - 0
A - 1
B - 1
C - 1
A - 2
B - 2
C - 2
A - 3
B - 3
C - 3
A - 4
B - 4
C - 4