线程共享经典面试题之交替输出三种解法

题目：

三个线程交替输出 abc，即要求输出 abcabcabcabcabc 该如何实现？（其中线程1 输出 a 5 次，线程2 输出b 5 次，线程3 输出 c 5 次）。

该题目可由下面三种解法：

如果对线程共享不了解的小伙伴可以去看看这篇文章：

看完之后这道面试题就迎刃而解了

一、wait & notify 版

通过设置等待标记 flag 来记录当前拥有锁的是哪个线程，设置下一个标记，来记录下一个唤醒的该是哪个线程。

参数一参数二参数三

输出内容等待标记(flag) 下一个标记 “a” 1 2 “b” 2 3 “c” 3 1

// 交替输出实现 之 wait & notify
public class Test11AlternateOutput {
    public static void main(String[] args) {
        WaitNotify wn = new WaitNotify(1,5);// 首先把等待标记设为1, 循环次数设为5次
        new Thread(() -> {
            wn.print("a",1,2);    // a的等待标记是1, 下一个标记是2
        }).start();
        new Thread(() -> {
            wn.print("b",2,3);    // b的等待标记是2, 下一个标记是3
        }).start();
        new Thread(() -> {
            wn.print("c",3,1);    // c的等待标记是3, 下一个标记是1
        }).start();
    }
}

/**
 *  输出内容    等待标记    下一个标记
 *    a          1          2
 *    b          2          3
 *    c          3          1
 */
class WaitNotify {
    // 等待标记
    private int flag;
    // 循环次数
    private int loopNumber;

    public WaitNotify(int flag, int loopNumber) {
        this.flag = flag;
        this.loopNumber = loopNumber;
    }

    // 打印
    public void print(String str, int waitFlag, int nextFlag) {
        for (int i = 0; i < loopNumber; i++) {
            synchronized (this) {
                // 未获得锁
                while(flag != waitFlag) {
                    try {
                        this.wait();        // 进入等待
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 获得了锁
                System.out.print(str);
                flag = nextFlag;            // 等待标记改为下一个标记
                this.notifyAll();           // 唤醒所有线程, 再与等待标记对比
            }
        }
    }
}

输出结果：

二、await & signal 版

由于 ReentrantLock 具有多个条件变量的特性，即多个 WaitSet 休息室，所以可以通过设置让其进入不同的休息室休息来实现输出当前线程的字符串，并唤醒下一个休息室中的线程。这种方法存在虚假唤醒的情况，因为没有做 while 判断，但此例中每个休息室中只有一个线程，因此不存在虚假唤醒的情况。

参数一参数二参数三

输出内容进入的休息室下一间休息室 “a” a b “b” b c “c” c a

import Java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

// 交替输出实现 之 await & signal
public class Test12AlternateOutput {
    public static void main(String[] args) {
        AwaitSignal as = new AwaitSignal(5);    // 循环5次
        Condition a = as.newCondition();                   // 休息室a
        Condition b = as.newCondition();                   // 休息室b
        Condition c = as.newCondition();                   // 休息室c
        new Thread(() -> {
            as.print("a",a,b);  // 去a休息室休息, 并唤醒b休息室中的线程
        }).start();
        new Thread(() -> {
            as.print("b",b,c);  // 去b休息室休息, 并唤醒c休息室中的线程
        }).start();
        new Thread(() -> {
            as.print("c",c,a);  // 去c休息室休息, 并唤醒a休息室中的线程
        }).start();

        Thread.sleep(1000);
        as.lock();
        try {
            System.out.println("开始...");
            a.signal();         // 先通过主线程唤醒 a
        } finally {
            as.unlock();
        }
    }
}

class AwaitSignal extends ReentrantLock {
    // 循环次数
    private int loopNumber;

    public AwaitSignal(int loopNumber) {
        this.loopNumber = loopNumber;
    }

    // 打印函数
    public void print(String str, Condition current, Condition next) {
        for (int i = 0; i < loopNumber; i++) {
            this.lock();            // 获取锁
            try {
                current.await();    // 到指定休息室休息
                System.out.print(str);
                next.signal();      // 唤醒下一间休息室中的线程
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                this.unlock();      // 释放锁
            }
        }
    }
}

输出结果：

三、park & unpark 版

由于 LockSupport 的 park() 方法可以暂停当前线程，unpark() 方法可以唤醒指定的线程，所以可以在执行完当前线程中的代码后，唤醒指定的线程。

参数一参数二

输出内容当前线程要唤醒的下一个线程 “a” t1 t2 “b” t2 t3 “c” t3 t1

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;

// 交替输出实现 之 park & unpark
public class Test13AlternateOutput {
    static Thread t1;
    static Thread t2;
    static Thread t3;
    public static void main(String[] args) throws InterruptedException {
        ParkUnpark pu = new ParkUnpark(5);  // 循环5次
        t1 = new Thread(() -> {
            pu.print("a",t2);   // 线程1下一个要唤醒线程2 
        });
        t2 = new Thread(() -> {
            pu.print("b",t3);   // 线程2下一个要唤醒线程3
        });
        t3 = new Thread(() -> {
            pu.print("c",t1);   // 线程3下一个要唤醒线程1
        });
        t1.start();
        t2.start();
        t3.start();

        LockSupport.unpark(t1);     // 先通过主线程唤醒t1线程
    }
}

class ParkUnpark{
    // 循环次数
    private int loopNumber;

    public ParkUnpark(int loopNumber) {
        this.loopNumber = loopNumber;
    }

    // 打印函数
    public void print(String str, Thread next) {
        for (int i = 0; i < loopNumber; i++) {
            LockSupport.park();         // 暂停当前线程
            System.out.print(str);
            LockSupport.unpark(next);   // 唤醒指定的下一个线程
        }
    }
}

输出结果：