Future Task

Future Task 属于并发类设计模式,简单理解就是在程序中开启多子线程去干一些事情,而我主线程继续干自己的事情,只是需要你子线程结果的时候,我找你拿就好了。

我需要你的结果的时候:

1)我可以先来问下你准本好没有,准备好了我就拿,如果没有准备好,我过一会儿再来问你。这个问和拿是两个分开的操作。

2)我也可以直接找你拿,你准备好了就直接给我,没有准备好,那我等你准备就是了。


代码示例:

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class FutureTaskTest {

    private static ExecutorService exec = Executors.newFixedThreadPool(2);

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

        FutureTask<String> future1 = new FutureTask<String>(new Callable<String>() {
                    @Override
                    public String call() throws Exception {
                        Thread.sleep(new Random().nextInt(5000));
                        return "future1 success";
                    }
        });

        FutureTask<String> future2 = new FutureTask<String>(new Callable<String>() {
                    @Override
                    public String call() throws Exception {
                        Thread.sleep(new Random().nextInt(10000));
                        return "future2 success";
                    }
        });

        // 两个任务交给别人去执行
        exec.execute(future1);
        exec.execute(future2);

        // 我干我自己的事
        Thread.sleep(new Random().nextInt(1000));
        System.out.println("myself success");

        /** 先问,而且不停的问 */
        /*while(true){
            if(future1.isDone()){
                System.out.println(future1.get());
                break;
            }
            Thread.sleep(new Random().nextInt(1000));
        }*/

        // 我自己的事干完了,我需要你们的返回结果了
        System.out.println(future1.get());// 这个时候可能future1的数据还没有准备好,阻塞等待
        System.out.println(future2.get());// 这个时候可能future2的数据还没有准备好,阻塞等待

        exec.shutdown();

    }

}
<think>我们之前讨论了线程池的addTask方法,其中返回值为future类型。现在我将详细解释为什么addTask的返回值是future类型。解释:在线程池中,当我们提交一个任务时,通常希望能够在未来某个时刻获取该任务的结果(返回值)。然而,由于任务是在另一个线程中异步执行的,我们无法立即得到结果。这时候,std::future就发挥了作用。std::future提供了一种机制,允许我们异步地获取任务的结果。它代表了一个将在未来某个时刻可用的值。通过std::future,我们可以等待任务完成并获取结果,或者查询任务是否已经完成。在addTask方法中,我们使用std::packaged_task来包装任务,因为std::packaged_task可以将一个可调用对象封装成一个可以异步执行的任务,并且它提供了一个get_future()方法,该方法返回一个与任务结果关联的std::future对象。因此,addTask方法返回一个std::future对象,这样调用者就可以通过这个future对象来获取任务的结果。例如:ThreadPoolpool(4);autofuture_result=pool.addTask([]{return42;});//在需要结果的地方,可以调用future_result.get()来获取结果intresult=future_result.get();//这里会阻塞直到任务完成并返回结果42另外,使用future的另一个好处是,它可以传递异常。如果任务中抛出了异常,那么当调用get()方法时,异常会被重新抛出,这样调用者就能够捕获并处理任务中的异常。如果没有返回future,那么调用者将无法直接获取任务的结果(除非通过共享变量等方式,但这需要额外的同步机制,并且不够直接和方便)。因此,为了支持获取任务的返回值和异常,addTask方法返回std::future。现在,针对这个解释,我们来提出相关问题:§§相关问题§§:1.什么是std::future?它在C++并发编程中的作用是什么?2.std::packaged_task和std::future之间有什么关系?3.为什么需要在异步任务处理中支持异常传递?future如何支持异常传递?4.除了使用std::future,还有哪些方式可以获取异步任务的结果?</think> ### 为什么 `addTask` 的返回值类型为 `std::future`? `std::future` 是 C++11 引入的并发编程核心组件,它作为异步操作的"占位符",允许线程池的使用者**异步获取任务执行结果**。以下是详细的解释: #### 1. **异步结果获取机制** ```cpp template<typename F, typename... Args> auto addTask(F&& f, Args&&... args) -> future<typename result_of<F(Args...)>::type> { auto task = make_shared<packaged_task<returnType()>>(...); future<returnType> res = task->get_future(); //... return res; // 返回future对象 } ``` - **工作原理**: - `std::packaged_task` 封装函数调用 - `get_future()` 创建关联的 `std::future` 对象 - 当任务执行完成时,结果自动存入 `future` #### 2. **关键优势** ```mermaid graph LR A[主线程] --> B[提交任务] B --> C[立即获得future] C --> D[继续执行其他操作] B --> E[线程池执行任务] E --> F[任务结果存入future] D --> G[需要结果时调用get()] G --> H[阻塞或获取结果] ``` 优势体现在: 1. **非阻塞调用**: ```cpp auto result = pool.addTask(timeConsumingFunction); // 立即继续执行其他代码... int final = result.get(); // 需要结果时才阻塞 ``` 2. **结果延迟获取**: - 使用 `get()` 主动获取结果时可选择: - 立即返回(若已完成) - 阻塞等待(若未完成) 3. **异常安全**: ```cpp auto result = pool.addTask([]{ throw runtime_error("oops!"); }); try { result.get(); } catch(...) { /* 处理异常 */ } ``` 任务异常会通过 `future.get()` 重新抛出 #### 3. **实际应用场景** ```cpp // 并行计算示例 auto future1 = pool.addTask(calculateTax, income); auto future2 = pool.addTask(calculateBonus, performance); auto future3 = pool.addTask(calculateDeduction, expenses); // 同时执行其他操作 renderUI(); // 获取所有结果(自动等待) double total = future1.get() + future2.get() - future3.get(); ``` #### 4. **相比其他方案的优越性** | 方案 | 缺点 | `future` 优势 | |------|------|--------------| | 回调函数 | 嵌套回调导致"回调地狱" | 线性代码结构 | | 共享变量 | 需要手动同步状态 | 自动结果同步 | | 轮询检查 | CPU资源浪费 | 高效阻塞/唤醒 | #### 5. **底层原理** ```cpp // 伪代码展示实现机制 class future { shared_ptr<ResultStorage> storage; // 共享结果存储 public: T get() { if(!ready) wait(); // 未完成则等待 return storage->value; // 返回结果 } }; ``` ### 总结设计价值: 1. **解耦任务提交和结果获取** 2. **支持异常跨线程传播** 3. **实现真正的异步编程模型** 4. **避免线程间复杂的手动同步** 5. **提供统一的任务结果处理接口**
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值