【并发编程】Java线程顺序执行方式

叁歲伎倆 2023-03-02 04:59 80阅读 0赞

# 前言 #

Github：[https://github.com/yihonglei/jdk-source-code-reading][https_github.com_yihonglei_jdk-source-code-reading]（java-concurrent）

# 概述 #

T1、T2、T3如何保证线程顺序执行？

直接上Demo吧！

# 一 Join方法 #

Join方法是最常用的方式，底层通过wait即加了synchronized同步锁和notify通知逻辑实现。

Join实现原理：[https://blog.csdn.net/u010983881/article/details/80257703][https_blog.csdn.net_u010983881_article_details_80257703]

package com.jpeony.concurrent.threadorder;
    
    /**
     * join控制线程顺序执行
     *
     * @author yihonglei
     */
    public class ThreadJoinOrder {
        public static void main(String[] args) throws InterruptedException {
            // 创建线程
            Thread t1 = new Thread(new Work(), "Thread-1");
            Thread t2 = new Thread(new Work(), "Thread-2");
            Thread t3 = new Thread(new Work(), "Thread-3");
    
            // 调用join
            t1.join();
            t2.join();
            t3.join();
    
            // 启动线程
            t1.start();
            t2.start();
            t3.start();
        }
    
        static class Work implements Runnable {
            @Override
            public void run() {
                System.out.println("thread start：" + Thread.currentThread().getName());
            }
        }
    }

**运行结果：**

![20200728133313792.png][]

# 二 FutureTask #

通过FutureTask的get()方法阻塞特性，控制线程顺序。

package com.jpeony.concurrent.threadorder;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.FutureTask;
    
    /**
     * FutureTask控制线程顺序，通过get方法阻塞获取上一个线程结果，只有当上一个线程执行完成并返回结果时，才继续执行下一个线程。
     *
     * @author yihonglei
     */
    public class FutureTaskOrder {
        public static void main(String[] args) {
            // 创建FutureTask
            FutureTask<String> task1 = new FutureTask<>(new Work(null));
            FutureTask<String> task2 = new FutureTask<>(new Work(task1));
            FutureTask<String> task3 = new FutureTask<>(new Work(task2));
    
            // 创建线程
            Thread t1 = new Thread(task1, "Thread-1");
            Thread t2 = new Thread(task2, "Thread-2");
            Thread t3 = new Thread(task3, "Thread-3");
    
            // 启动线程
            t1.start();
            t2.start();
            t3.start();
        }
    
        static class Work implements Callable<String> {
            private FutureTask<String> beforeTask;
    
            Work(FutureTask<String> beforeTask) {
                this.beforeTask = beforeTask;
            }
    
            @Override
            public String call() throws Exception {
                if (beforeTask != null) {
                    // 阻塞等待，上一个线程执行完，才能继续执行
                    beforeTask.get();
                    System.out.println("thread start：" + Thread.currentThread().getName());
                } else {
                    System.out.println("thread start：" + Thread.currentThread().getName());
                }
                return "Result " + Thread.currentThread().getName();
            }
        }
    }

**运行结果：**

![20200728135405968.png][]

# 三 NewSingleThreadExecutor #

Executors.newSingleThreadExecutor()：线程池只有一个工作线程，工作线程从BlockingQueue阻塞有序队列取任务执行，

从而保证线程的顺序性执行。

线程池实现原理：[https://blog.csdn.net/yhl\_jxy/article/details/86677049][https_blog.csdn.net_yhl_jxy_article_details_86677049]

package com.jpeony.concurrent.threadorder;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    /**
     * Executors.newSingleThreadExecutor()：线程池只有一个工作线程，工作线程从BlockingQueue阻塞有序队列取任务执行，
     * 从而保证线程的顺序性执行。
     *
     * @author yihonglei
     */
    public class NewSingleThreadExecutorOrder {
        public static void main(String[] args) {
            // 单个线程池，保证线程依次执行顺序
            ExecutorService executorService = Executors.newSingleThreadExecutor();
    
            // 创建线程
            Thread t1 = new Thread(new Work("one"));
            Thread t2 = new Thread(new Work("two"));
            Thread t3 = new Thread(new Work("three"));
    
            // 提交线程池
            executorService.submit(t1);
            executorService.submit(t2);
            executorService.submit(t3);
    
            // 关闭线程池
            executorService.shutdown();
        }
    
        static class Work implements Runnable {
            private String orderName;
    
            Work(String orderName) {
                this.orderName = orderName;
            }
    
            @Override
            public void run() {
                System.out.println("thread start：" + orderName);
            }
        }
    }

**运行结果：**

![20200728135426393.png][]

# 四 CompletableFuture #

CompletableFuture为Java8新特性。

CompletableFuture使用说明：[https://juejin.im/post/5edf454c518825433a57c4c9][https_juejin.im_post_5edf454c518825433a57c4c9]

package com.jpeony.concurrent.threadorder;
    
    import java.util.concurrent.CompletableFuture;
    
    /**
     * CompletableFuture顺序执行任务
     *
     * @author yihonglei
     */
    public class CompletableFutureOrder {
        public static void main(String[] args) {
            CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> {
                System.out.println("Thread-1");
                return "one";
            });
    
            cf.thenRun(() -> {
                System.out.println("Thread-2");
            });
    
            cf.thenRun(() -> {
                System.out.println("Thread-3");
            });
        }
    }

**运行结果：**

![20200728135622158.png][]

# 五 队列顺序性 #

通过阻塞队列+while循环控制线程的顺序性，或者通过ArrayList控制线程的顺序，

但是需要在每个线程执行完成时自己从队列移出元素。

package com.jpeony.concurrent.threadorder;
    
    import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingQueue;
    
    /**
     * 通过阻塞队列+while循环控制线程的顺序性，或者通过ArrayList控制线程的顺序，但是需要在每个线程执行完成时自己从队列移出元素。
     *
     * @author yihonglei
     */
    public class BlockingQueueOrder {
        public static void main(String[] args) throws InterruptedException {
            // 创建线程
            Thread t1 = new Thread(new Work(), "Thread-1");
            Thread t2 = new Thread(new Work(), "Thread-2");
            Thread t3 = new Thread(new Work(), "Thread-3");
            // 队列保证顺序性
            BlockingQueue<Thread> blockingQueue = new LinkedBlockingQueue<>();
            blockingQueue.add(t1);
            blockingQueue.add(t2);
            blockingQueue.add(t3);
    
            for (int i = 0; i < 3; i++) {
                Thread take = blockingQueue.take();
                take.start();
                while (take.isAlive()) ;
            }
    
            // 主线程保持存活
            Thread.sleep(3000);
        }
    
        static class Work implements Runnable {
            @Override
            public void run() {
                System.out.println("thread start：" + Thread.currentThread().getName());
            }
        }
    }

**运行结果：**

![2020072813571824.png][]

# 六 CountDownLatch #

CountDownLatch控制线程执行顺序，通过await方法为0时，线程才会执行特性，阻塞线程执行，通过上一个线程执行完成，

减掉下一个线程的计数器，使下一个线程计数器为0，线程变为可执行，来控制线程执行顺序。

CountDownLatch实现原理：[https://blog.csdn.net/yhl\_jxy/article/details/87181895][https_blog.csdn.net_yhl_jxy_article_details_87181895]

package com.jpeony.concurrent.threadorder;
    
    import java.util.concurrent.CountDownLatch;
    
    /**
     * CountDownLatch控制线程执行顺序，通过await方法为0时，线程才会执行特性，阻塞线程执行，通过上一个线程执行完成，
     * 减掉下一个线程的计数器，使下一个线程计数器为0，线程变为可执行，来控制线程执行顺序。
     *
     * @author yihonglei
     */
    public class CountDownLatchOrder {
        public static void main(String[] args) {
            // 计数器为0
            CountDownLatch threadC1 = new CountDownLatch(0);
            // 计数器为1
            CountDownLatch threadC2 = new CountDownLatch(1);
            // 计算器为2
            CountDownLatch threadC3 = new CountDownLatch(1);
    
            // threadC1计数器为0，t1线程执行，然后threadC2计数器被减为0
            Thread t1 = new Thread(new Work(threadC1, threadC2), "Thread-1");
            // threadC2计数器为0，t2线程执行，然后threadC3计数器被减为0
            Thread t2 = new Thread(new Work(threadC2, threadC3), "Thread-2");
            // threadC3计数器为0，t3线程执行
            Thread t3 = new Thread(new Work(threadC3, threadC3), "Thread-3");
            
            // 启动线程
            t1.start();
            t2.start();
            t3.start();
        }
    
        static class Work implements Runnable {
            // 当前要执行线程的计数器
            private CountDownLatch current;
            // 下一个要执行线程的计数器
            private CountDownLatch next;
    
            Work(CountDownLatch current, CountDownLatch next) {
                this.current = current;
                this.next = next;
            }
    
            @Override
            public void run() {
                try {
                    // 计数器为0，则可执行，否则线程被阻塞
                    current.await();
                    System.out.println("thread start：" + Thread.currentThread().getName());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    // 计数器减1，将计数器变为0，通知等待线程尝试获取锁执行
                    next.countDown();
                }
            }
        }
    }

**运行结果：**

![20200728135829218.png][]

[https_github.com_yihonglei_jdk-source-code-reading]: https://github.com/yihonglei/jdk-source-code-reading
[https_blog.csdn.net_u010983881_article_details_80257703]: https://blog.csdn.net/u010983881/article/details/80257703
[20200728133313792.png]: /images/20230208/ccd4a6fa8a1e4cd28a2350a6c9f3e2f6.png
[20200728135405968.png]: /images/20230208/f1dfde9021e14a1da17f5ad5b93da7b0.png
[https_blog.csdn.net_yhl_jxy_article_details_86677049]: https://blog.csdn.net/yhl_jxy/article/details/86677049
[20200728135426393.png]: /images/20230208/b9ff90a8eb52404daee2f854acf291c0.png
[https_juejin.im_post_5edf454c518825433a57c4c9]: https://juejin.im/post/5edf454c518825433a57c4c9
[20200728135622158.png]: /images/20230208/ff1d4a4696634dc881313cf4ecf0d3f1.png
[2020072813571824.png]: /images/20230208/f31fbcd6334144a190ed0e7329bea81a.png
[https_blog.csdn.net_yhl_jxy_article_details_87181895]: https://blog.csdn.net/yhl_jxy/article/details/87181895
[20200728135829218.png]: /images/20230208/254d7542123a4d72aca67d8845687e0c.png