- Hello，我是Lorin 洛林，今天继续为朋友们带来了多线程系列知识分享，想必大家面试时都遇到一个经典的面试题：用多线程实现循环打印123？
- 听到这个问题，对多线程熟悉的朋友想必是信手拈来，今天我也来分享几种实现方式，看看和大家的思路是否一致，大家有其它思路也可以在评论区分享，话不多说开始发车。
问题分析
- 多线程循环顺序打印 123？很明显，这个问题是考察我们对线程同步的掌握程度，一想到线程同步，我们可以想到 join、使用锁进行线程同步（synchronized、ReentrantLock等等）等等方式实现，下面我们按照这些思路一一进行实现。
实现思路
基于 join 实现
- join 的作用是阻塞当前线程，直到其它线程不再活动，因此我们可以按照这个思路让线程串行执行，顺序打印123。
/**
* 循环次数
*/
private volatile static int loopNum = 5000;
/**
* volatile 保证内存可见性
*/
private volatile static int currentValue = 1;
/**
* Join 可以保证线程顺序执行，可以通过 Join 的方式串行执行
* 创建 5000 个线程，每个线程需要等待前一个线程执行完成，从而实现串行执行
*
* 思考：这里是采用直接创建循环次数的线程数，可以优化为只维护两个线程的方式，即首节点线程执行完成后创建新线程执行
*/
private static void cyclePrintUseJoin() {
Thread preThread = null;
for (int i = 0; i < loopNum; i++) {
preThread = new Thread(new JoinTask(preThread));
preThread.start();
}
}
static class JoinTask implements Runnable {
private final Thread preThread;
public JoinTask(Thread thread) {
this.preThread = thread;
}
@Override
public void run() {
// 如果 preThread 不为空表示不是头节点线程需要等待 preThread 执行完成
if (preThread != null) {
try {
preThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(currentValue);
if (currentValue == 3) {
currentValue = 1;
} else {
currentValue++;
}
}
}
- 这里留了一个问题给大家思考：这里是采用直接创建循环次数的线程数，可以优化为只维护两个线程的方式，即首节点线程执行完成后再创建新线程
基于 synchronized 实现
- 使用 synchronized 同步代码块进行同步，让多线程串行执行
/**
* 循环次数
*/
private volatile static int loopNum = 5000;
/**
* volatile 保证内存可见性
*/
private volatile static int currentValue = 1;
private static final Object lockObj = new Object();
/**
* 使用 synchronized 串行执行代码块
*/
private static void cyclePrintUseSynchronized() {
new Thread(new SynchronizedTask()).start();
new Thread(new SynchronizedTask()).start();
new Thread(new SynchronizedTask()).start();
}
static class SynchronizedTask implements Runnable {
@Override
public void run() {
while (true) {
synchronized (Test1.class) {
if (loopNum < 0) {
return;
}
System.out.println(currentValue);
if (currentValue == 3) {
currentValue = 1;
} else {
currentValue++;
}
loopNum--;
}
}
}
}
升级版 Plus：保证指定数字由指定线程打印
- 上面线程打印 1 2 3 由哪一个线程打印并不能保证，面试官此时会问，如何让指定线程打印对应数字，这时候我们就需要把对应的数字绑定到对应线程，当打印的数字和线程绑定的数字相同时才进行打印。
/**
* 循环次数
*/
private static int loopNum = 5000;
/**
* 当前打印数字
*/
private static int currentValue = 1;
private static final Object lockObj = new Object();
/**
* 使用 synchronized 串行执行代码块
* 且对应线程只处理对应任务
*/
private static void cyclePrintUseSynchronizedPlus() {
new Thread(new SynchronizedTaskPlus(1)).start();
new Thread(new SynchronizedTaskPlus(2)).start();
new Thread(new SynchronizedTaskPlus(3)).start();
}
static class SynchronizedTaskPlus implements Runnable {
private final int target;
public SynchronizedTaskPlus(int target) {
this.target = target;
}
@Override
public void run() {
while (true) {
synchronized (lockObj) {
if (loopNum < 0) {
return;
}
if (currentValue != target) {
try {
// 这里为了避免过多的无效抢占锁，使当前线程 进入等待状态（获取到锁但打印的数字和线程的绑定的数字不一样）
lockObj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(currentValue);
if (currentValue == 3) {
currentValue = 1;
} else {
currentValue++;
}
loopNum--;
// 注：这里需要唤醒所有的线程，因为唤醒的线程可能不是目标线程，导致无效唤醒
lockObj.notifyAll();
}
}
}
}
基于 ReentrantLock 实现
- ReentrantLock 和 synchronized 实现方式基本一致，但有一些细微的区别：ReentrantLock 只能保证有序性，无法保证可见性，因此需要使用 volatile 修饰变量保证多线程间的可见性。
/**
* 循环次数
*/
private volatile static int loopNum = 5000;
/**
* volatile 保证内存可见性
*/
private volatile static int currentValue = 1;
private static final ReentrantLock reentrantLock = new ReentrantLock();
/**
* 使用 ReentrantLock 串行执行代码块
*/
private static void cyclePrintUseReentrantLock() {
new Thread(new ReentrantLockTask()).start();
new Thread(new ReentrantLockTask()).start();
new Thread(new ReentrantLockTask()).start();
}
static class ReentrantLockTask implements Runnable {
@Override
public void run() {
while (true) {
reentrantLock.lock();
try {
if (loopNum < 0) {
return;
}
System.out.println(currentValue);
if (currentValue == 3) {
currentValue = 1;
} else {
currentValue++;
}
loopNum--;
} finally {
reentrantLock.unlock();
}
}
}
}
升级版 Plus：保证指定数字由指定线程打印
-
实现思路和方式可以参考 synchronized 案例中的实现。大家可以自己动手实现一下。