Hanhan's Blog

异步线程：folly::Future 通常与异步执行器（如 EventBase 或 ManualExecutor）一起使用，这些执行器可以在单独的线程中运行。这样，当发起网络请求或其他耗时操作时，可以在后台线程中进行，而不会阻塞主线程。
非阻塞调用：通过使用 .then()、.via() 等方法，你可以将异步操作的回调链起来，这些回调将在操作完成时自动执行，而不会阻塞当前线程。

避免阻塞主线程的方法

链式调用：

auto future = folly::makeFuture()
    .then([=](Try<Unit>&&) {
        // 发起网络请求
        return networkRequest();
    })
    .then([=](Try<std::string>&& result) {
        // 处理网络请求的结果
        if (result.hasValue()) {
            std::cout << "Network response: " << result.value() << std::endl;
        } else {
            std::cout << "Network error: " << result.exception().what() << std::endl;
        }
    });

在这个例子中，网络请求在后台线程中异步执行，主线程不会阻塞。

**使用 ****.wait()**或.get()：

如果你需要在某个点等待异步操作完成，可以使用 .wait() 或 .get()，但这些方法可能会阻塞当前线程：
```
auto future = networkRequest();
future.wait(); // 阻塞当前线程，直到 future 完成
auto result = future.get(); // 获取结果，可能会抛出异常
```

**使用 ****.thenValue()**或.thenTry()：

这些方法允许你指定一个回调函数，当异步操作完成时，回调函数将被调用：

networkRequest().thenValue([=](Try<std::string>&& result) {
    if (result.hasValue()) {
        std::cout << "Network response: " << result.value() << std::endl;
    } else {
        std::cout << "Network error: " << result.exception().what() << std::endl;
    }
});

**使用 ****folly::SemiFuture**和.via()：

folly::SemiFuture 允许你指定一个执行器（如 Executor），回调将在该执行器上执行：
```
auto semiFuture = networkRequest().semi();
auto future = semiFuture.via(someExecutor);
```
在这个例子中，回调将在 someExecutor 指定的执行器上执行，这可以是一个在后台线程中运行的执行器。

总结

folly::Future 实现异步操作的方式是通过与异步执行器结合使用，而不是简单地在主线程中阻塞等待。通过合理地使用 .then()、.via()、.thenValue() 等方法，你可以确保主线程不会被阻塞，同时能够处理异步操作的结果。

如果你确实需要在某个点等待异步操作完成，可以使用 .wait() 或 .get()，但要注意这可能会阻塞当前线程。为了避免这种情况，尽量使用非阻塞的异步处理方式。

是的，someExecutor 在 folly::Future 和 folly::SemiFuture 的上下文中通常指的是一个执行器（Executor），它可以是一个线程池。在 Folly 中，执行器是一个抽象概念，用于封装执行任务的逻辑，它可以是一个简单的线程、线程池、事件循环或其他并发机制。

以下是一些可以作为执行器使用的组件：

folly::IOThreadPoolExecutor：这是一个线程池，可以用于执行 I/O 密集型任务。它允许你将任务提交到一个共享的线程池中，而不是创建新的线程。
folly::CPUThreadPoolExecutor：这是一个 CPU 密集型任务的线程池。与 I/O 线程池不同，CPU 线程池通常用于执行计算密集型任务。
folly::EventBase：这是一个事件循环，常用于处理 I/O 事件。它可以与 folly::Future 结合使用，通过 .thenValue() 或 .thenTry() 将回调提交到事件循环中。
folly::ManualExecutor：这是一个手动驱动的执行器，你可以手动调用其 drive() 方法来执行任务。这在测试或某些特殊场景中非常有用。
folly::GlobalExecutor：这是一个全局执行器，通常用于默认的异步任务执行。

示例：使用线程池作为执行器

以下是如何使用 folly::IOThreadPoolExecutor 作为执行器的示例：

#include <folly/executors/CPUThreadPoolExecutor.h>
#include <folly/futures/Future.h>

int main() {
    // 创建一个线程池执行器
    auto threadPool = std::make_shared<folly::IOThreadPoolExecutor>(4); // 4 个线程

    // 创建一个异步任务
    folly::Future<int> future = folly::makeFuture(0)
        .via(threadPool)
        .thenValue([](int x) {
            // 模拟一些耗时操作
            std::this_thread::sleep_for(std::chrono::seconds(1));
            return x + 1;
        });

    // 获取结果
    int result = future.get();
    std::cout << "Result: " << result << std::endl;

    return 0;
}

在这个示例中，folly::Future 的回调通过 via() 方法提交到 IOThreadPoolExecutor，这意味着回调将在线程池中的一个线程上执行。

注意事项

线程池的选择：根据你的任务类型（I/O 密集型或 CPU 密集型）选择合适的线程池。
资源管理：确保线程池在不再需要时被正确地关闭和释放资源。
执行器的生命周期：执行器的生命周期应至少与使用它的 folly::Future 或 folly::SemiFuture 一样长。

通过这种方式，你可以有效地利用线程池来处理异步任务，提高程序的并发性和响应性。

future

目录

异步操作的实现

避免阻塞主线程的方法

总结

示例：使用线程池作为执行器

注意事项

Comments 0