多个线程按顺序执行_futuretask按顺序-优快云博客

本文链接：https://blog.youkuaiyun.com/trusause/article/details/120203200

本文详细介绍了Java中三种多线程同步的方法：使用join实现线程间的顺序执行，利用CountDownLatch进行线程同步，以及通过FutureTask获取有返回值的多线程结果。每个方法都配合实例代码进行了详细解析，展示了它们在实际编程中的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

方法一：join

public class hacker_01_RunableImpl_join {
    public static void main(String[] args) {

        Thread th1=new Thread(new RunableImp("A"));
        Thread th2=new Thread(new RunableImp("B"));
        th1.start();
        th2.start();
        try{
            th1.join();
            th2.join();

        }
        catch(Exception e){e.printStackTrace();}

        System.out.println("主线程结束");
    }

    static class RunableImp implements Runnable
    {
        private String name;

        public RunableImp(String name) {
            this.name = name;
        }
        @Override
        public void run() {
            System.out.println(this.name+"开始执行");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.name+"执行结束");
        }
    }
}

结果：

方法二：countDownLatch

static class RunableImp2 implements Runnable
    {
        private String name;
        private CountDownLatch latch;

        public RunableImp2(String name, CountDownLatch latch) {
            this.name = name;
            this.latch = latch;
        }

        @Override
        public void run() {
            System.out.println(this.name+"开始执行");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(this.name+"执行结束");
            latch.countDown();
        }
    }

// CountDownLatch 方式二实现主线程等待子线程执行完再执行
    public static void CountDownLatch() throws InterruptedException {
        CountDownLatch cdl=new CountDownLatch(2);

        Thread th1=new Thread(new RunableImp2("A",cdl));
        Thread th2=new Thread(new RunableImp2("B",cdl));
        th1.start();
        th2.start();
        cdl.await();
        System.out.println("主线程执行完");
    }

结果：

方法三：FutureTask对象，有返回值的多线程执行

static class CallableImp implements Callable{
        private String name;
        public CallableImp(String name) {
            this.name = name;
        }

        @Override
        public Object call() throws Exception {
            System.out.println(this.name+"开始执行");
            Thread.sleep(3000);
            return this.name+"执行完成";
        }
    }

// Callable FutureTask 方式三实现主线程等待子线程执行完再执行
    public static void FutureTask() throws ExecutionException, InterruptedException {
        FutureTask task1=new FutureTask(new CallableImp("A"));
        FutureTask task2=new FutureTask(new CallableImp("B"));
        Thread th1=new Thread(task1);
        Thread th2=new Thread(task2);
        th1.start();
        th2.start();

        if(!task1.isDone()&&!task2.isDone()){
            System.out.println("子线程正在执行中");
        }
        System.out.println(task1.get());
        System.out.println(task2.get());

    }

结果：