java 多线程按顺序执行、顺序获取结果

最新推荐文章于 2024-05-16 00:24:10 发布
最新推荐文章于 2024-05-16 00:24:10 发布
阅读量5k 收藏 29
点赞数 3
分类专栏： Android面试 文章标签： 多线程 java 顺序 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tongsiw/article/details/110951336
版权

文章目录

1、通过Thread的join方法

join主要是让父线程等待子线程结束之后父线程才能继续运行

    public static void main(String[] args) throws InterruptedException {
        System.out.println("---开启线程1---");
        MyThread t1 = new MyThread("线程1");
        t1.start();
        t1.join();

        System.out.println("---开启线程2---");
        MyThread t2 = new MyThread("线程2");
        t2.start();
        t2.join();

        System.out.println("---开启线程3---");
        MyThread t3 = new MyThread("线程3");
        t3.start();
        t3.join();
        
    }
    
    static class MyThread extends Thread {
        public MyThread(String name){
            super(name);
        }
        @Override
        public void run() {
            super.run();
            System.out.println(Thread.currentThread().getName()+"执行了");
        }
    }

打印结果

---开启线程1---
线程1执行了
---开启线程2---
线程2执行了
---开启线程3---
线程3执行了

2、FutureTask

   public static void main(String[] args) throws InterruptedException, ExecutionException {
        System.out.println("---开启线程1---");
        FutureTask<String> f1 = new FutureTask<>(new MyCall());
        Thread t1 = new Thread(f1,"线程1");
        t1.start();
        System.out.println("线程1返回结果： " + f1.get());

        System.out.println("---开启线程2---");
        FutureTask<String> f2 = new FutureTask<>(new MyCall());
        Thread t2 = new Thread(f2,"线程2");
        t2.start();
        System.out.println("线程2返回结果： " + f2.get());

        System.out.println("---开启线程3---");
        FutureTask<String> f3 = new FutureTask<>(new MyCall());
        Thread t3 = new Thread(f3,"线程3");
        t3.start();
        System.out.println("线程3返回结果： " + f3.get());
    }
    
    
    static class MyCall implements Callable<String> {
        @Override
        public String call() throws Exception {
            return Thread.currentThread().getName();
        }
    }

打印结果

---开启线程1---
线程1返回结果： 线程1
---开启线程2---
线程2返回结果： 线程2
---开启线程3---
线程3返回结果： 线程3

3、CountDownLatch（倒计数）

现在有如下3个线程

   public static void main(String[] args) throws InterruptedException, ExecutionException {

        System.out.println("---开启线程1---");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(500);
                    System.out.println("线程1执行了。。。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "线程1");
        t1.start();

        System.out.println("---开启线程2---");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(200);
                    System.out.println("线程2执行了。。。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "线程2");
        t2.start();

        System.out.println("---开启线程3---");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(100);
                    System.out.println("线程3执行了。。。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程3");
        t3.start();
    }

它们的执行结果是

---开启线程1---
---开启线程2---
---开启线程3---
线程3执行了。。。
线程2执行了。。。
线程1执行了。。。

上面的输出是按照3、2、1输出的。如果现在要按照1、2、3的顺序进行输出，每个线程的sleep时间不能修改，该如何去处理？可以借助CountDownLatch

    private static CountDownLatch c1 = new CountDownLatch(1);
    private static CountDownLatch c2 = new CountDownLatch(1);
    public static void main(String[] args) throws InterruptedException, ExecutionException {

        System.out.println("---开启线程1---");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(500);
                    System.out.println("线程1执行了。。。");
                    c1.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "线程1");
        t1.start();

        System.out.println("---开启线程2---");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    c1.await();
                    Thread.sleep(200);
                    System.out.println("线程2执行了。。。");
                    c2.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "线程2");
        t2.start();

        System.out.println("---开启线程3---");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    c2.await();
                    Thread.sleep(100);
                    System.out.println("线程3执行了。。。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程3");
        t3.start();
    }

它们的执行结果是

---开启线程1---
---开启线程2---
---开启线程3---
线程1执行了。。。
线程2执行了。。。
线程3执行了。。。

4、wait、notify

    private final static Object lock1 = new Object();
    private final static Object lock2 = new Object();
    
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        System.out.println("---开启线程1---");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock1) {
                    try {
                        lock1.wait();
                        Thread.sleep(500);
                        System.out.println("线程1执行了。。。");
                        lock1.notify();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "线程1");
        t1.start();
        Thread.sleep(10);//这个主要保证线程开启的顺序
        
        System.out.println("---开启线程2---");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock1) {
                    try {
                        lock1.notify();
                        lock1.wait();
                        Thread.sleep(200);
                        System.out.println("线程2执行了。。。");
                        synchronized (lock2) {
                            lock2.notify();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        }, "线程2");
        t2.start();
        Thread.sleep(10);
        
        System.out.println("---开启线程3---");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock2) {
                    try {
                        lock2.wait();
                        Thread.sleep(100);
                        System.out.println("线程3执行了。。。");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "线程3");
        t3.start();

    }

打印结果

---开启线程1---
---开启线程2---
---开启线程3---
线程1执行了。。。
线程2执行了。。。
线程3执行了。。。

5、Condition(条件变量)

    private static Lock lock = new ReentrantLock();
    private static Condition condition1 = lock.newCondition();
    private static Condition condition2 = lock.newCondition();

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        System.out.println("---开启线程1---");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    condition1.await();
                    Thread.sleep(500);
                    System.out.println("线程1执行了。。。");
                    condition1.signal();
                    lock.unlock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程1");
        t1.start();

        System.out.println("---开启线程2---");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    condition1.signal();
                    condition1.await();
                    Thread.sleep(200);
                    System.out.println("线程2执行了。。。");
                    condition2.signal();
                    lock.unlock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程2");
        t2.start();

        System.out.println("---开启线程3---");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    condition2.await();
                    Thread.sleep(100);
                    System.out.println("线程3执行了。。。");
                    lock.unlock();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程3");
        t3.start();
    }

打印结果

---开启线程1---
---开启线程2---
---开启线程3---
线程1执行了。。。
线程2执行了。。。
线程3执行了。。。

6、CyclicBarrier(回环栅栏)

    private static CyclicBarrier barrier1 = new CyclicBarrier(2);
    private static CyclicBarrier barrier2 = new CyclicBarrier(2);

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        System.out.println("---开启线程1---");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(500);
                    System.out.println("线程1执行了。。。");
                    barrier1.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }, "线程1");
        t1.start();

        System.out.println("---开启线程2---");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    barrier1.await();
                    Thread.sleep(200);
                    System.out.println("线程2执行了。。。");
                    barrier2.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }, "线程2");
        t2.start();

        System.out.println("---开启线程3---");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    barrier2.await();
                    Thread.sleep(100);
                    System.out.println("线程3执行了。。。");
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }
        }, "线程3");
        t3.start();
    }

打印结果

---开启线程1---
---开启线程2---
---开启线程3---
线程1执行了。。。
线程2执行了。。。
线程3执行了。。。

5、线程池

5.1、单线程化线程池

    private static ExecutorService executorService = Executors.newSingleThreadExecutor();

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        System.out.println("---开启线程1---");
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(500);
                    System.out.println("线程1执行了。。。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程1");


        System.out.println("---开启线程2---");
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(200);
                    System.out.println("线程2执行了。。。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程2");


        System.out.println("---开启线程3---");
        Thread t3 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(100);
                    System.out.println("线程3执行了。。。");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "线程3");
        executorService.submit(t1);
        executorService.submit(t2);
        executorService.submit(t3);
    }

打印结果

---开启线程1---
---开启线程2---
---开启线程3---
线程1执行了。。。
线程2执行了。。。
线程3执行了。。。

5.2、多线程化线程池

其实最常见的还是使用多线程化的线程池去实现。

    private static ExecutorService executorService = Executors.newFixedThreadPool(3);
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        long start = System.currentTimeMillis();
        ArrayList<Future<String>> futureList = new ArrayList<Future<String>>();
        ArrayList<String> names = new ArrayList<String>();
        for (int i = 0; i < 3; i++) {
            futureList.add(executorService.submit(new MyCall(i + "")));
        }

        for (int i = 0; i < 3; i++) {
            Future<String> future = futureList.get(i);
            String value = future.get();
            System.out.println("线程"+value+"执行了");
        }
        long spendTime = System.currentTimeMillis() - start;
        System.out.println("花费时间---"+spendTime);

    }
    
    
    static class MyCall implements Callable<String> {
        private String name;

        public MyCall(String name) {
            this.name = name;
        }

        @Override
        public String call() throws Exception {
            switch (name){
                case "0":
                    Thread.sleep(3000);
                    break;
                case "1":
                    Thread.sleep(2000);
                    break;
                case "2":
                    Thread.sleep(1000);
                    break;
            }

            return name;
        }
    }

打印结果

线程0执行了
线程1执行了
线程2执行了
花费时间---3006

常见的问题：

  • 1、2、3总共3个线程，按顺序请求，按顺序取结果。
  • 1、2、3总共3个线程，线程3要等到线程1和2执行完才能执行，线程1和2是并行的。
  • 写一个多线程程序，交替输出1,2,1,2,1,2

相信上面的问题应该不难了。。

在这里插入图片描述

T-bright
关注
  • 3
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java thread怎么保证线程按顺序执行？如何实现线程排队？
呆咖啡的博客
07-22 299
在Java中，通常不保证多个线程按特定顺序执行，因为线程的调度是由操作系统管理的，并且是不可预测的。
让线程按顺序执行8种方法
weixin_30872337的博客
03-25 941
转载请注明出处：https://www.cnblogs.com/wenjunwei/p/10573289.html 一.前言 本文使用了7中方法实现在多线程中让线程按顺序运行的方法，涉及到多线程中许多常用的方法，不止为了知道如何让线程按顺序运行，更是让读者对多线程的使用有更深刻的了解。 使用的方法如下: [1] 使用线程的join方法 [2] 使用主线程的join方法 [3] 使用线...
Java多线程按指定顺序同步执行
08-25
主要介绍了java多线程如何按指定顺序同步执行,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
JAVA实现多个线程顺序执行的几种方式
Android
09-26 7225
题目描述：如何保证多个线程的顺序执行？ join方式实现 join方式即使用Thread.join方法来实现。Thread.join含义当前线程需要等待previousThread线程终止之后才从thread.join返回。简单来说，就是线程没有执行完之前，会一直阻塞在join方法处。 join方式实现方式存在两种：主线程join和执行线程join。下面我们依次来分析一下： 1.主线程join 上面源码就是主线程join的实现方式，其原理就是保证执行线程执行完毕再start后续线程，从而.
Java多线程之顺序执行
xtho62的博客
02-20 616
【代码】Java多线程之顺序执行。
java 线程顺序执行_Java多线程按指定顺序同步执行
weixin_29031057的博客
02-12 382
笔者今天看到一个有趣的面试题，如何让多个线程按照既定的顺序依次执行？比如每个线程输出一个整数，那么期望就是这样的：0，1，2，3，4，5，6，7，8，9. 而不是0，2，4，1，3，5，8，7，9，6乍一看，这不是反人性的考题吗？多线程本来就以乱序执行出名的。稍加思索，想到3种解决方案，分别用代码实现之。方法1 使用newSingleThreadExecutornewSingleThreadExe...
java多线程编码,顺序执行（同步）
帐前卒 专栏
06-11 2216
java线程实现机制：1.继承Thread类，并实现run方法。2.传递Runnable类。例如： public class TestThread extends Thread...{  public void run()//继承Thread后必须实现的方法 ...{    for(int i = 0; i  3; i++)    System.out.println(i); 
【Java多线程】实现线程按顺序执行
ChrisLee2013的博客
07-20 254
【代码】【Java多线程】实现线程按顺序执行。
让线程按顺序执行8种方法.doc
10-05
本文将介绍让线程按顺序执行的8种方法，涉及到多线程中许多常用的方法，不止为了知道如何让线程按顺序运行，更是让读者对多线程的使用有更深刻的了解。 一、使用线程的join方法 join()是Thread的方法，作用是调用...
java 多线程顺序输出_java多线程顺序执行并顺序输出ABC问题
weixin_33594621的博客
02-19 1009
1.有A、B、C、D四个线程，A线程输出A, B线程输出B, C线程输出C，D线程输出D，要求, 同时启动四个线程, 按顺序输出ABCD；本题主要通过join方法来实现顺序输出ABCD。代码如下：package thread;/*** @author Beauxie*/public class TestThread1 {public static void main(String[] args) ...
Java实现指定线程执行顺序的三种方式示例
08-26
在多线程编程中，我们经常需要让不同的线程按照一定的顺序执行，以避免线程之间的相互干扰和数据不一致的问题。今天，我们将讨论Java实现指定线程执行顺序的三种方式。 第一种方式：通过共享对象锁加上可见变量来...
java 多线程保证顺序_ABC三个线程如何保证顺序执行
weixin_39734987的博客
02-25 2321
介绍最近看看多线程练习题，练习下多线程，这道题：ABC三个线程如何保证顺序执行。三个线程同时启动，然后按照顺序执行，每个线程执行10次。思路首先想到了等待队列Condition唤醒部分线程，使用ReentrantLock进行加锁。初始版实现/*** @description A\B\C三个线程顺序执行10次** @author sunpy* @date 2018年11月28日 下午2:23:45...
java多线程实现顺序执行
qq_27081015的博客
02-14 1881
1.使用线程的join方法 public static void main(String[] args) { final Thread t1 = new Thread(new Runnable() { @Override public void run() { System.out.println("起床"); } }); final Thread t2
Java多线程——如何控制线程顺序执行，如何控制线程同时执行_java 执行顺序控制(3)
最新发布
2401_84562810的博客
05-16 1241
线程过多会带来额外的开销，频繁创建和销毁大量线程需要占用系统资源，消耗大量时间。其中包括创建销毁线程的开销、调度线程的开销等等，同时也降低了计算机的整体性能。线程池维护多个线程，等待监督管理者分配可并发执行的任务。这种做法，一方面避免了处理任务时创建销毁线程开销的代价，另一方面避免了线程数量膨胀导致的过分调度问题，保证了对内核的充分利用。
java-多线程执行顺序
xiaodangshan的博客
04-05 764
栈中有四个线程：主线程、Thread-0和Thread-1、Thread-2线程。如果有多个线程在排队，那么CPU的执行权是随机抢占的，但是无论哪个线程抢占到CPU的执行权，在线程中都是自上而下执行代码。 代码： package cx.thread; public class CreateTherad { public static void main(Stri...
Java多线程顺序执行
Site_Dave的博客
02-26 2173
此方法实现java多线程顺序执行,依赖的是LinkedList &amp;amp;lt; Runnable &amp;amp;gt; ,链表里的元素是有序的,先放进去的先出来,所以最先进去的CreateTaskByThread最先出来. 其次consumptionThread 线程监听tasks里面放进去的任务,类似于消费者,如果有任务的话会立即执行,消费掉tasks里面的任务;productionThread 线程负责向Lin...
java 多个线程顺序执行_Java中多个线程按顺序执行
weixin_33896830的博客
02-13 274
基本思想：建立了一个队列，为每一个Thread保存了一个对象锁，保证按顺序执行。线程启动的时候，使随机的，但是执行代码是按顺序的。import java.util.LinkedList;import java.util.Queue;public class ThreadTest {private static Queue qThread=new LinkedList();//线程同步对象队列pub...
Java多线程获取执行结果
Lucifer ZHAO
03-01 3510
一、Thread.join() 特点：一个线程等待另一个线程结束后才能执行。利用此原理我们可以设置一个监控线程用来等待程序线程执行完毕后输出返回结果。 public class Result { private String value; public String getValue() { return value; } public void setValue(String value) { this.value = value;
Java中控制多线程顺序执行
weixin_45295678的博客
09-06 5894
Java的线程调度策略是基于线程优先级的抢占式调度，同优先级的线程的执行顺序是看JVM心情的、不可预测的。那有什么办法来控制多线程按照开发者意愿的顺序执行呢？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值