线程池 submit()执行怎么获取到的返回值

最新推荐文章于 2024-09-04 10:01:37 发布
最新推荐文章于 2024-09-04 10:01:37 发布
阅读量3.7k 收藏 2
点赞数 2
分类专栏： 集合源码+JUC源码 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45862170/article/details/122026725
版权

Java创建线程有三种方法，1是继承Thread类，2是实现Runnable接口，3是实现Callable接口

1和2差不多，就是一个是继承关系，继承了Thread类就不能继承其它类的，会有困扰。而实现接口却可实现多个。

而且继承Thread类去实现的run方法实际还是Runnable中的run方法

前提

执行submit()方法会返回一个Future。这个future.get()可以阻塞获取值

demo- 21-40 行是创建一个线程池，重点关注42，49，57代码快

package study4;

import java.util.concurrent.*;

public class ThreadPoolDemo {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4,
                60, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(10),
                new ThreadFactory() {
                    @Override
                    public Thread newThread(Runnable r) {
                        return new Thread(r, "线程");
                    }
                }, new RejectedExecutionHandler() {
                        @Override
                        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                            System.out.println("执行拒绝策略");
                            try {
                                throw new RejectedExecutionException();
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                        }
                }
        );

        Future<?> submit1 = threadPoolExecutor.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("submit1执行任务");
            }
        });

        Future<String> submit2 = threadPoolExecutor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "submit2执行了任务";
            }
        });

        final String[] res = {new String("有什么用？")};
        Future<String> submit3 = threadPoolExecutor.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("submit3执行了任务");
                res[0] = new String("123");
                return;
            }
        }, res[0]);

        try {
            System.out.println("submit2 get "+submit2.get());
            System.out.println("submit3 get "+ res[0]);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }

        threadPoolExecutor.shutdown();
    }
}

分析1和3 方法

直接放入实现Runnable接口的任务。

Future<?> submit1 = threadPoolExecutor.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("submit1执行任务");
            }
        });
 
 final String[] res = {new String("有什么用？")};
        Future<String> submit3 = threadPoolExecutor.submit(new Runnable() {
            @Override
            public void run() {
                System.out.println("submit3执行了任务");
                res[0] = new String("123");
                return;
            }
        }, res[0]);

也就是submit(Runnable) 和 submit(Runnalbe,Object)一个带Object参数，一个不带。结果就是带Object的可以返回返回值。
源码查看

  public Future<?> submit(Runnable task) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<Void> ftask = newTaskFor(task, null);
        execute(ftask);
        return ftask;
    }
    
    
    public <T> Future<T> submit(Runnable task, T result) {
        if (task == null) throw new NullPointerException();
        RunnableFuture<T> ftask = newTaskFor(task, result);
        execute(ftask);
        return ftask;
    }

可以看到，带不带都调用了RunnableFuture ftask = newTaskFor(task, result); 然后又执行了execute()方法
可以说，submit()此时和execute()方法此时区别就是RunnableFuture类。

看一下源码，发现此接口同时继承了Runnalbe和Future接口

public interface RunnableFuture<V> extends Runnable, Future<V> {
   
    void run();
}

其实，最终是落到了它的实现类FutureTask，作用就是将Runnable转为Callable，并且设置返回值。

看一下 newTaskFor(task, result);源码

protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
        return new FutureTask<T>(runnable, value);
    }
    
    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);  //此行就可看出，将Runnable转为了callable
        this.state = NEW;      
    }
    
     public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }
    
    RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
    }
    
    static final class RunnableAdapter<T> implements Callable<T> {
        final Runnable task;
        final T result;
        RunnableAdapter(Runnable task, T result) {
            this.task = task;
            this.result = result;
        }
        public T call() {
            task.run();
            return result;
        }
    }

这个RunnableAdapter实现了Callable，然后通过构造参数将runable封装起来。如果result不为null，代表此时runnable也需要返回值。

result是返回值，那么怎么获取到runnable中的返回值呢，就是Future怎么就可以通过get获取到？

debug一下流程

首先执行的是runnable。但是之前说RunnableAdapter将它封装为Callable方法，那么就是通过

        public T call() {
            task.run(); 
            return result;
        }

实现的。并且返回result。

Runnable结论

最终可以观察到，即使是Runnable也是通过了一些方法转化为Callable。或者说是被封装为Callable。

分析2

继续分析第二个代码块，也就是直接

  Future<String> submit2 = threadPoolExecutor.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                return "submit2执行了任务";
            }
        });

这个是怎么将返回值让future.get()可以获取到的？
其实一看源代码，都一样，这个是直接将callable赋值给FutureTask

 public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
    this.callable = Executors.callable(runnable, result);  //此行就可看出，将Runnable转为了callable

之前的还需要封装

那么也就应该是FutureTask解决的返回值问题。
debug发现直接跳到了futureTask的run()方法

再这个方法中调用了之前封装或者原装的Callable的result = c.call();
call可以有返回值，result
然后调用一个set()方法，将result赋值给FutureTask中的private Object outcome;

public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }
    
      private V report(int s) throws ExecutionException {
        Object x = outcome;
        if (s == NORMAL)
            return (V)x;
        if (s >= CANCELLED)
            throw new CancellationException();
        throw new ExecutionException((Throwable)x);
    }
    
    //可以通过get方法得知，它就是获取的outcome的值

最终回答

这个只是一些表面的。但是主要流程也是这

回答问题：
线程池 submit()执行怎么获取到的返回值

如果是Runnable接口的任务，则先封装为Callable，然后通过FutureTask调用call方法，由
call方法调用run方法。run中可返回数据，就是给submit(runnable,Object) Object赋值

如果是Callable，则不封装，直接使用原装的callable。

返回值的话是call方法有返回值，这个返回值会被赋值给Future的一个私有属性。然后
程序中调用Future会获取到这个私有属性的值。

天上飞的云传奇
关注
专栏目录
Java线程池submit阻塞获取结果实现原理
m0_71777195的博客
10-23 1534
Java线程池中提交任务运行，通常使用execute()方法就足够了。那如果想要实现在主线程中阻塞获取线程池任务运行的结果，该怎么办呢？答案是用submit()方法提交任务。这也是面试中经常被问到的一个知识点，execute()和submit()提交任务的的区别是什么？底层是如何实现的？submit()方法中调用方法获取对象。// 调用FutureTask的构造方法返回RunnableFuture对象}复制代码FutureTaskFutureTask是一个异步计算任务，包装了我们外部提交的任务。
Java手写线程池（不带返回值、带返回值）
今天你学习了吗
09-17 250
文章目录不带返回值带返回值 不带返回值 public class MyThreadPool { private static final int DEFAULT_THREAD_NUM = 10; private int maxThreadNum; private BlockingQueue<Runnable> queue; // 初始化worker的时候直接调用start方法 // 在run中不断从阻塞队列中获取对象 // 由于已经调用了start方法，是一个新的线
c++ socket线程池原理_线程池续：你必须要知道的线程池submit()实现原理之FutureTask
weixin_39818521的博客
11-25 383
前言讲解线程提交的submit()方法，submit()有一个返回值，可以获取线程执行的结果Future，这一讲就那深入学习下submit()和FutureTask实现原理。使用场景&示例使用场景我能想到的使用场景就是在并行计算的时候，例如一个方法中调用methodA()、methodB()，我们可以通过线程池异步去提交方法A、B，然后在主线程中获取组装方法A、B计算后的结果，能够大大提升...
Java多线程-线程池ThreadPoolExecutor的submit返回值Future
花飘万家雪
11-06 6786
一般使用线程池执行任务都是调用的execute方法，这个方法定义在Executor接口中： public interface Executor { void execute(Runnable command); } 1 2 3 这个方法是没有返回值的，而且只接受Runnable。 那么像得到线程的返回值怎嘛办呢？ 在ExecutorService接口中能找到这个方法： <T> Future<T> submit(Callable<T> task);
【多线程】线程池之exectue与submit的区别
最新发布
qq_39666711的博客
09-04 512
背景：在日常进行多线程的开发过程中，遇见了有的线程池用excute提交子线程任务，有的使用submit提交线程任务。execute和submit都属于线程池的方法，那这两种有什么区别呢？我们一起来验证一下。
如何通过submit提交form获取后台传来的返回值
热门推荐
【欢迎关注公众号：冬瓜白】
03-08 3万+
原文地址：http://blog.csdn.net/qq_34651764/article/details/76373846 小伙伴是不是遇到过这样的问题，通过submit提交form表单的时候，不知怎么获取后台传来的返回值。有的小伙伴就会说你不会发送ajax，其实小编也会。假如提价的form表单中含有文件，怎么办？（注：其实小编不会如何用ajax把选择文件上传到后台，如果有会的小伙伴可以分享一...
线程池submit方法如何获取执行结果
笔记小屋
01-15 1717
FutureTask 来获取线程结果
简单谈谈ThreadPoolExecutor线程池之submit方法
08-30
"ThreadPoolExecutor线程池之submit方法详解" 在 Java 中，...ThreadPoolExecutor 的 submit 方法提供了多种方式来执行任务，并且可以获取任务的返回值，这使得我们可以更灵活地使用线程池来执行任务。
java 多线程 实现 无返回值 有返回值 Runnable Thread Callable＜T＞ Future＜String＞ FutureTask＜String＞ 线程池获取
银河系天城知识宝库_技术专家蒋浩宇
05-06 1970
介绍 这里篇文章介绍 java 线程实现，有返回值和无返回值的实现方法，以及 获取返回值的方法 实现 Runnable 继承 Thread 实现 Callable<t> 获取返回值 futurefutureTask 或线程池ExecutorService .submit(Callable<t>实现类)； 上一篇：java 线程锁 可重入锁 可中断锁 公平锁 非公平锁ReentrantLock synchronized,条件Condition,读写锁 Reentran...
线程池和返回值线程
majunzhu的博客
11-19 186
public static void main(String[] args) throws ExecutionException, InterruptedException { List<String> list = new ArrayList<>(); list.add("1"); list.add("2"); list.add("3")...
线程池的submit和execute的区别.md
09-26
MarkDown文档，意在说明线程池方法：submit()和execute()方法的区别
博客摘录「 Java多线程-线程池ThreadPoolExecutor的submit返回值Future」2023年8月15日
liangdingguo的博客
08-15 486
System.out.println(Thread.currentThread().getName() + " 没有成功获取到分布式锁，锁已经被占用" + System.currentTimeMillis());System.out.println(Thread.currentThread().getName() + " 已经成功获取到的分布式锁" + System.currentTimeMillis());//最后进行解锁操作，如果服务宕机，则到不了这一步，会等待看门狗监控锁结束锁清除。
Java多线程之线程池submit任务及get返回值流程详解
xyqintj的专栏
04-01 6275
通过案例分析线程池类Executors相关的ExecutorService的submit方法和Callable的call方法调用流程。有这样一个需求：获取多个任务的返回结果，根据这些任务的返回结果来决定当前线程该做什么。
如何通过submit提交form表单获取后台传来的返回值
syq8023的博客
06-20 9576
jquery.js jquery-form.js 步骤1：写一个form表单 <formaction="链接"id="form1"method="post"style="text-align:center;"enctype="multipart/form-data"> <inputtype="file"id="file_sc"name="fi...
submit获取返回值_Runnable定义任务，跑完就拉倒？不，我就想要个返回值
weixin_39623271的博客
12-16 281
作者 | Java圣斗士 | 原创图文，转载请注明出处全文3500字，阅读需要15分钟，建议收藏哈喽大家好，我是又皮又Demo的Java圣斗士，今天又给大家带干货来了！快来关注一波！有一些小伙伴问了，圣斗士呀，你咋总写一些多线程的东西啊？这些东西日常开发都用不上的呀，知道实现线程的方式有两种，一种是继承Thread，另一种是实现Runnable接口不就OK了吗？！对这些小伙伴我只能说，TOO YO...
如何从提交的表单里面获取数据
weixin_47414034的博客
12-26 659
在这个表单中规定了：表单中的数据会emo/test这个方法。
源码分析下为什么线程池的submit()可以接收返回值
绅士jiejie的博客
04-17 529
先看看submit()方法的源码： public <T> Future<T> submit(Callable<T> task) { //空值判断 if (task == null) throw new NullPointerException(); //设置构造一个RunnableFuture对象 ...
线程池submit与execute的区别详解
`ExecutorService`接口提供了`execute()`和`submit()`两个方法来提交任务到线程池执行。 ## `execute()`方法 `execute()`方法主要用于提交一个实现了`Runnable`接口的任务。它没有返回值，这意味着一旦任务被提交，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值