分享一道阿里笔试题
朋友们许久不见，你们还好吗？
这段时间里，我也悄咪咪的去试了试外面的机会，2 年没有参加面试发现各大厂的面试风格已经悄悄的发生了变化。
前俩年都是喜欢上来一套 JUC 三连炮问到你懵圈为止，要不就是一套 Mysql 事务三连炮问到你瑟瑟发抖。而现在呢，面试官们喜欢揪着你的项目刨根问底。你可能会说，唉我的项目就是一堆 CRUD，没啥可说的。
不用担心，面试官会就你的业务场景，改造一下，现场创造一些难点来让你提出解决方案。你以为想到解决方案就完了吗？too naive！这时候你才刚刚走进面试官的陷阱，接着面试官会开始对你进行惨无人道（都是搬砖的，相煎何太急）的狂轰乱炸。
此时没有准备充分的你，就像一只站在大灰狼面前的小肥羊，孤独无助，任由大灰狼的皮鞭肆虐。
所以朋友们面试之前一定要多多准备，找几家不想去的公司试试水，同时也要多刷刷数据结构，线程方面的算法题。
这不，我在阿里第一轮笔试的结束的时候就碰到了这么一道题：
使用 3 个线程 A，B，C 来按顺序依次打印 1 – 100 的数字。
效果为：A => 1，B => 2，C => 3，A => 4，B => 5，C => 6，A => 7，…..
相信 synchronized 使用熟练的同学可以很快的输出如下一个解决方案：
public class ThreadPrint {
private static int number = 1 ;
private static final Object LOCK = new Object();
public static void main (String[] args) {
Thread a = new Thread( new Runnable(){
@Override
public void run () {
while ( true ) {
synchronized (LOCK) {
if (number > 100 ) {
System.out.println( “A over” );
LOCK.notifyAll();
break ;
}
if (number % 3 == 1 ) {
System.out.println(Thread.currentThread().getName() + ” => “ + number);
number++;
} else {
try {
LOCK.notifyAll();
LOCK.wait();
} catch (Exception ex) {
System.out.println(ex);
}
}
}
}
}
}, “Thread-A” );
a.start();
Thread b = new Thread( new Runnable(){
@Override
public void run () {
while ( true ) {
synchronized (LOCK) {
if (number > 100 ) {
System.out.println( “B over” );
LOCK.notifyAll();
break ;
}
if (number % 3 == 2 ) {
System.out.println(Thread.currentThread().getName() + ” => “ + number);
number++;
} else {
try {
LOCK.notifyAll();
LOCK.wait();
} catch (Exception ex) {
System.out.println(ex);
}
}
}
}
}
}, “Thread-B” );
b.start();
Thread c = new Thread( new Runnable(){
@Override
public void run () {
while ( true ) {
synchronized (LOCK) {
if (number > 100 ) {
System.out.println( “C over” );
LOCK.notifyAll();
break ;
}
if (number % 3 == 0 ) {
System.out.println(Thread.currentThread().getName() + ” => “ + number);
number++;
} else {
try {
LOCK.notifyAll();
LOCK.wait();
} catch (Exception ex) {
System.out.println(ex);
}
}
}
}
}
}, “Thread-C” );
c.start();
}
}
当你乐呵呵的告诉面试官写完了的时候，他会微微点头告诉你，嗯，首先这是一个可以 work 的方案，但是呢代码稍微有些冗余，可以优化一下吗。
这三个线程的内部运转逻辑基本一致，唯一区别就是取模运算时候的值不同，因此我们可以将代码改进一下：
public class ThreadPrint {
private static final Object LOCK = new Object();
public static void main (String[] args) {
new PrintThread( 1 , “Thread-A” , LOCK).start();
new PrintThread( 2 , “Thread-B” , LOCK).start();
new PrintThread( 0 , “Thread-C” , LOCK).start();
}
}
class PrintThread extends Thread {
private int mod;
private String name;
private static int number = 1 ;
private Object LOCK;
public PrintThread ( int mod, String name, Object lock) {
this .mod = mod;
this .name = name;
this .LOCK = lock;
}
@Override
public void run () {
while ( true ) {
synchronized (LOCK) {
if (number > 100 ) {
System.out.println(name + “over” );
LOCK.notifyAll();
break ;
}
if (number % 3 == mod) {
System.out.println(name + ” => “ + number);
number++;
} else {
try {
LOCK.notifyAll();
LOCK.wait();
} catch (Exception ex) {
System.out.println(ex);
}
}
}
}
}
}
当你坑此坑次的精简了代码后，面试官笑嘻嘻的说，嗯，现在精简了不少。突然他脸上漏出了狡黠的笑容，还有其他解法吗。
嗯，我想想，你陷入了沉思。突然灵光一闪，我可以用信号量来替换管程，接着你写出了如下的代码：
import java.util.concurrent.Semaphore;
public class ThreadPrint {
private static final Object LOCK = new Object();
private static final Semaphore semaphore = new Semaphore( 1 , false );
public static void main (String[] args) {
new PrintThread( 1 , “Thread-A” , semaphore).start();
new PrintThread( 2 , “Thread-B” , semaphore).start();
new PrintThread( 0 , “Thread-C” , semaphore).start();
}
}
class PrintThread extends Thread {
private int mod;
private String name;
private static int number = 1 ;
private Semaphore semaphore;
public PrintThread ( int mod, String name, Semaphore semaphore) {
this .mod = mod;
this .name = name;
this .semaphore = semaphore;
}
@Override
public void run () {
while ( true ) {
try {
semaphore.acquire();
if (number > 100 ) {
System.out.println(name + “over” );
semaphore.release();
break ;
}
if (number % 3 == mod) {
System.out.println(name + ” => “ + number);
number++;
}
semaphore.release();
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
没错，使用管程可以解决的线程间互斥问题，采用信号量一样可以解决。当你认为终于可以告一段落的时候，面试官仍然不会放过你，还有其他方法吗？
你假装思索片刻，奥奥，还有一种办法可以使用 ReentrantLock 来解决：
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ThreadPrint {
private static final Lock lock = new ReentrantLock( false );
public static void main (String[] args) {
new PrintThread( 1 , “Thread-A” , lock).start();
new PrintThread( 2 , “Thread-B” , lock).start();
new PrintThread( 0 , “Thread-C” , lock).start();
}
}
class PrintThread extends Thread {
private int mod;
private String name;
private static int number = 1 ;
private Lock lock;
public PrintThread ( int mod, String name, Lock lock) {
this .mod = mod;
this .name = name;
this .lock = lock;
}
@Override
public void run () {
while ( true ) {
try {
lock.lock();
if (number > 100 ) {
System.out.println(name + “over” );
break ;
}
if (number % 3 == mod) {
System.out.println(name + ” => “ + number);
number++;
}
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
你飞速的敲击键盘，将原本采用 Semaphore 的方案替换为了 ReentrantLock，心里想，这下总该满意了吧。
然而并不像你想象的那么简单，面试官再次漏出狡黠的笑容，你现在的方案呢存在一个问题，就是三个线程会同时争抢资源，这样会导致某个线程抢占到了锁资源，但是又没到它打印的数字，有没有办法优化一下这个问题呢？
你陷入了沉思，不同时竞争锁，打印又是有序的，那就由 A 线程打印完数字后，A 去唤醒 B，然后 A进入睡眠；接着 B 打印完数字唤醒 C，然后 B 进入睡眠；最后 C 打印数字，然后唤醒 A，接着 C 进入睡眠，以此类推即可完成循环打印，并且同时只有一个线程在运行。
那使用什么方式来实现呢，聪明的你一定想到了 Condition：
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ThreadPrint {
private static final Lock lock = new ReentrantLock( false );
private static Condition cOver = lock.newCondition();
private static Condition aOver = lock.newCondition();
private static Condition bOver = lock.newCondition();
public static void main (String[] args) {
new PrintThread( 1 , “Thread-A” , lock, cOver, bOver).start();
new PrintThread( 2 , “Thread-B” , lock, aOver, cOver).start();
new PrintThread( 0 , “Thread-C” , lock, bOver, aOver).start();
}
}
class PrintThread extends Thread {
private int mod;
private String name;
private static int number = 1 ;
private Lock lock;
private Condition wait;
private Condition notify;
public PrintThread ( int mod, String name, Lock lock, Condition wait, Condition notify) {
this .mod = mod;
this .name = name;
this .lock = lock;
this .notify = notify;
this .wait = wait;
}
@Override
public void run () {
while ( true ) {
try {
lock.lock();
if (number > 100 ) {
System.out.println(name + “over” );
notify.signal();;
break ;
}
if (number % 3 == mod) {
System.out.println(name + ” => “ + number);
number++;
}
notify.signal();
wait.await();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
}
相信当你作出如上的解决方案后，面试官应该会漏出慈母般的微笑，并且伴随着频频点头，心里已经对你扎实的基本功竖起来大拇指。
如上即为我们今天要介绍的这道并发编程面试题，里面总共采用了四种方法去解决这个问题，层层递进不断优化。
如果你对上面的几种解法还不能烂熟于心，那你要抓紧巩固哦，不然容易给面试官留下一个理论王者的面评就不好啦。
About The Author
