让线程乖乖~按顺序执行

雨点打透心脏的1/2处 2021-09-23 08:28 321阅读 0赞

最近总是遇到这样的问题：怎么控制线程访问顺序？怎么让线程B在线程A执行之后再执行？怎么让线程A、B、C按顺序打印ABCABC?     以上都可以归结为线程的顺序执行问题，有这么4种方案：

（1）join()：“等你执行结束，我再执行”

（2）singleThreadPool：只有一个线程的线程池，任务乖乖在队列中等待被执行

（3）wait/notify机制：“兄弟们，醒醒，到你了”

（4）ReentrantLock 的 condition 的 await/signal机制：“那个兄弟，醒醒，到你了”

接下来就这四种方式进行详细说明

### 一、Join() ###

1、简介：join()，等待线程结束，才能继执行。

2、本质：让线程wait在当前线程对象实例上，观察join的源码：

public final void join() throws InterruptedException {
            join(0);
        }

public final synchronized void join(long millis)
        throws InterruptedException {
            long base = System.currentTimeMillis();
            long now = 0;
    
            if (millis < 0) {
                throw new IllegalArgumentException("timeout value is negative");
            }
    
            //---------重点-------------
            if (millis == 0) {
                while (isAlive()) {
                    wait(0);
                }
            //--------------------------
            } else {
                while (isAlive()) {
                    long delay = millis - now;
                    if (delay <= 0) {
                        break;
                    }
                    wait(delay);
                    now = System.currentTimeMillis() - base;
                }
            }
        }

解读：阻塞当前线程，直到目标线程运行结束，如果参数是0，意味着无限等待。

**3、join实现线程顺序执行**

**（1）方式1：在run()中调用join方法。**

public class M1 {
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread(() -> System.out.println("A"));
            Thread t2 = new Thread(() -> {
                try {
                    t1.join();  //瞧，线程2等待线程1执行结束，然后再执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("B");});
            Thread t3 = new Thread(() -> {
                try {
                    t2.join();  //线程3等待线程2执行结束，然后再执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("C");});
            t1.start();
            t3.start();
            t2.start();
            //输出：A B C
        }
    }

**（2）方式2：在主方法中调用join**

public class M2 {
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread(() -> System.out.println("A"));
            Thread t2 = new Thread(() -> System.out.println("B"));
            Thread t3 = new Thread(() -> System.out.println("C"));
            t1.start();
            t1.join();
            t2.start();
            t2.join();
            t3.start();
            //输出：A  B  C
        }
    }

### 二、单线程线程池 ###

1、简介：只有一个线程的线程池，任务都在等待队列中排队，所以它们是一个一个执行的

2、两种创建方式：

ExecutorService single=new ThreadPoolExecutor(1,1,0, TimeUnit.SECONDS,new LinkedBlockingDeque<>());
    ExecutorService single = Executors.newSingleThreadExecutor();

**3、单线程线程池实现顺序执行**

public class M2 {
        public static void main(String[] args){
            Thread t5=new Thread(()->System.out.println("A"));
            Thread t6=new Thread(()->System.out.println("B"));
            Thread t7=new Thread(()->System.out.println("C"));
            ExecutorService single=new ThreadPoolExecutor(1,1,0, TimeUnit.SECONDS,new LinkedBlockingDeque<>());
            single.submit(t5);
            single.submit(t7);
            single.submit(t6);
        }
    }

### 三、wait/notify机制 ###

1、简介：有多种实现方式，这里介绍通过一个变量的取值来控制线程执行顺序。

注意：wait/notify 要求获得对象的monitor，所以只能在同步方法或同步代码块中使用

**2、wait/notify实现线程顺序执行**

*  先创建一个类，类中包含一个变量，flag。我们约定，flag=0时，输出A，flag=1时，输出B，flag=2，输出C

class MyThread {
        private static int flag=0;
        //str：稍后要打印的值；order：取值范围[0,1,2]，分别代表先后顺序
        public synchronized void printStr(String str,int order){
            while (flag!=order){
                try{
                    this.wait(); //否则释放锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(str);
            if (order<2)
                flag++;
            else
                flag=1;
            this.notifyAll(); //唤起其他线程
        }
    }

*  主方法中调用

public class M3 {
        public static void main(String[] args) throws InterruptedException {
            MyThread myThread = new MyThread();
            Thread t8 = new Thread(new Runnable() {
                @Override
                public void run() {
                    myThread.printStr("A", 0); //第一个，打印A
                }
            });
            Thread t9 = new Thread(new Runnable() {
                @Override
                public void run() {
                    myThread.printStr("B", 2); //第3，打印B
                }
            });
            Thread t10 = new Thread(new Runnable() {
                @Override
                public void run() {
                    myThread.printStr("C", 1); //第二，打印C
                }
            });
            t8.start();
            t9.start();
            t10.start();
            //执行结果：A    C     B
        }
    }

### 四、condition的await/signal机制 ###

1、简介：这个机制和wait/notify很像，（笔者狭隘地认为，condition一定情况下可以更加精确~）

2、Conditon：await/signal要配合ReentrantLock使用，通过ReentrantLock的newConditon方法生成一个与当前重入锁绑定的Condition实例，让我们能在线程何时的时间等待，或在一个特定的时刻获得通知。阻塞队列之所以能够阻塞，底层也是利用了condition哦

**3、await/signal实现线程顺序执行**

public class M5{
        private static Lock lock=new ReentrantLock();
        private static Condition condition1=lock.newCondition();
        private static Condition condition2=lock.newCondition();
        private static boolean printA=true;  //先打印A
        private static boolean printB=false; //先打印B
        public static void main(String[] args) throws InterruptedException {
            Thread t11=new Thread(() -> {
                try{
                    lock.lock();
                    if (!printA) {
                       condition1.await(); //如果当前printA=false，则在条件1上等待
                    }
                    System.out.println("A");
                    printB=true;
                    printA=false;
                    condition2.signal(); //唤醒在condition2上等待的线程
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            });
            Thread t12=new Thread(() -> {
                try{
                    lock.lock();
                    if (!printB){
                        condition2.await(); 
                    }
                    System.out.println("B");
                    printA=true;
                    printB=false;
                    condition1.signal();
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            });
            t11.start();
            t12.start();
        }
    
    }

参考资料：

1、《Java高并发程序设计》

2、让线程按顺序执行8种方法：[https://www.cnblogs.com/wenjunwei/p/10573289.html][https_www.cnblogs.com_wenjunwei_p_10573289.html]

[https_www.cnblogs.com_wenjunwei_p_10573289.html]: https://www.cnblogs.com/wenjunwei/p/10573289.html