多线程顺序执行

前言

现在面试中，不光会问力扣之类的算法，手撕多线程问题也被提上了日程。多线程之间的顺序执行是一个高频的面试手撕题，而且在实际应用中也会有用武之地。因此在这里，我们考虑使用不同的方式来实现多线程的顺序执行。在本文中，我们采用了syncronize,ReentrantLock,join等方式来实现顺序执行。

方法实现

syncronize配合wait/notify

本方法采用sync提供的锁机制配合等待通知来实现多线程的顺序执行。具体代码如下：

public class ExcuteOrder {
    private final Object lock=new Object();
    private int current=1;
    public static void main(String[] args) {
        ExcuteOrder excuteOrder = new ExcuteOrder();
        excuteOrder.printOrder();
    }
    public void printOrder(){
        new Thread(()->printNums(3)).start();
        new Thread(()->printChars(2)).start();
        new Thread(()->printCH(1)).start();
    }
    public void printNums(int orderNum){
        synchronized (lock){
            while (orderNum!=current) {
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            for(int i=1;i<=3;i++){
                System.out.print(i);
            }
            current++;
            lock.notifyAll();
        }
    }
    public void printChars(int orderNum){
        synchronized (lock){
            while (orderNum!=current){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            for(char i='A';i<='C';i++){
                System.out.print(i);
            }
            current++;
            lock.notifyAll();
        }
    }
    public void printCH(int orderNum){
        synchronized (lock){
            while (orderNum!=current){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.print("你好");
            current++;
            lock.notifyAll();
        }
    }
}

此处设计的方法中传入一个执行编号，与成员变量进行比较，可以使得这几个线程以我们想执行的任意顺序来执行。

lock-condition配合await/signal

设计思路与上面类似，但是使用的是JDK提供的ReentrantLock，相较于sync，它能够提供更灵活的等待条件，并且它的等待通知机制更为灵活，从功能上也可以实现多线程的顺序执行。具体实现代码如下：

public class LockConditionFlow {
    private int currentNums=1;
    private ReentrantLock lock=new ReentrantLock();
    private Condition condition=lock.newCondition();

    public static void main(String[] args) {
        LockConditionFlow lockConditionFlow = new LockConditionFlow();
        lockConditionFlow.printFlow();
    }
    public void printFlow(){
        new Thread(()->printNums(1)).start();
        new Thread(()->printChars(2)).start();
        new Thread(()->printChinese(3)).start();
    }
    public void printNums(int excuNum){
        lock.lock();
        while (excuNum!=currentNums){
            try {
                condition.await();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
            for(int i=1;i<=3;i++){
                System.out.print(i);
            }
            currentNums++;
        condition.signalAll();
        lock.unlock();
    }
    public void printChars(int excuNums){
        lock.lock();
        while (excuNums!=currentNums){
            try {
                condition.await();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        for(char i='A';i<='C';i++){
            System.out.print(i);
        }
        currentNums++;
        condition.signal();
        lock.unlock();
    }
    public void printChinese(int excuNums){
        lock.lock();
        while (excuNums!=currentNums){
            try {
                condition.await();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        System.out.print("你好");
        currentNums++;
        condition.signalAll();
        lock.unlock();
    }
}

join

join的使用相对较简单，它会阻塞调用此方法的线程，并等待上一个线程执行结束才能执行，具体实现代码如下：

public class PrintFlowJoin {
    public static void main(String[] args) {
        PrintFlowJoin printFlowJoin = new PrintFlowJoin();
        printFlowJoin.print();
    }
    public void print(){
        Thread thread1 = new Thread(this::printNums);
        Thread thread2 = new Thread(() -> {
            try {
                thread1.join();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            printChars();
        });
        Thread thread3 = new Thread(() -> {
            try {
                thread2.join();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            printChinese();
        });
        thread1.start();
        thread2.start();
        thread3.start();
    }
    public void printNums(){
        for(int i=1;i<=3;i++){
            System.out.print(i);
        }
    }
    public void printChars(){
        for(char i='A';i<='C';i++){
            System.out.print(i);
        }
    }
    public void printChinese(){
        System.out.print("你好");
    }
}

CountDownLatch

它的思想在于等待countDownLatch的计数器置为零之后唤醒等待在该countDownLatch上的线程，比较适用于多个线程等待某个线程执行完毕之后再执行，类似于一种并行的思想，当然也可以用来实现多个线程的顺序执行，具体代码如下：

public class ExcuteCountDown {
    public static void main(String[] args) {
        ExcuteCountDown excuteCountDown = new ExcuteCountDown();
        excuteCountDown.excute();
    }
    public void excute(){
        CountDownLatch countDownLatch1 = new CountDownLatch(1);
        CountDownLatch countDownLatch2 = new CountDownLatch(1);
        Thread thread1 = new Thread(() -> {
            countDownLatch1.countDown();
            System.out.println("Thread1");
        });
        Thread thread2 = new Thread(() -> {
            try {
                countDownLatch1.await();
                System.out.println("Thread2");
                countDownLatch2.countDown();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        Thread thread3 = new Thread(() -> {
            try {
                countDownLatch2.await();
                System.out.println("Thread3");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        thread1.start();
        thread2.start();
        thread3.start();

    }
}

总结

这几种方案都可以来实现线程的顺序执行，但是它们也有一些区别。sync的方法实现起来比较简单，但是需要手动等待和通知容易造成死锁；而lock-condition的方式提供了更为灵活的等待通知机制，并且可以提供多个condition，所以灵活性很高，但是需要对lock-condition的使用很熟徐；join方法使用也非常简单，只能实现一些简单场景的线程顺序执行；最后是CountDownLatch，它比较适合更为复杂的线程协作场景。