1
#include <future>
2
#include <thread>
3
#include <iostream>
4
int main() {
5
    std::cout << "主线程 id = " << std::this_thread::get_id() << std::endl;
6
    // 策略一：launch::async —— 一定在新线程里立刻执行
7
    auto f1 = std::async(std::launch::async, [] {
8
        std::cout << "async  任务跑在     " << std::this_thread::get_id() << std::endl;
9
        return 1;
10
    });
11
    std::cout << "async  结果 = " << f1.get() << std::endl;
12
    // 策略二：launch::deferred —— 不启动！等 get() 时才在当前线程（主线程）里执行
13
    auto f2 = std::async(std::launch::deferred, [] {
14
        std::cout << "deferred 任务跑在     " << std::this_thread::get_id() << std::endl;
15
        return 2;
16
    });
17
    std::cout << "deferred 结果 = " << f2.get() << std::endl;   // 这一行执行时才真正运行上面的 lambda
18
    // 策略三：默认策略（等同于 async | deferred）—— 由实现决定，通常也是新线程
19
    auto f3 = std::async([] {
20
        std::cout << "默认  任务跑在     " << std::this_thread::get_id() << std::endl;
21
        return 3;
22
    });
23
    std::cout << "默认  结果 = " << f3.get() << std::endl;
24
}

1
#include <future>
2
#include <string>
3
#include <iostream>
4
// 普通函数也可以
5
int add(int a, int b) { return a + b; }
6
int main() {
7
    // 传函数指针 + 参数
8
    std::future<int> f1 = std::async(std::launch::async, add, 3, 4);
9
    std::cout << f1.get() << std::endl;   // 7
10
    // 传 lambda + 参数；std::cref 表示按"引用"传，避免拷贝大对象
11
    std::string big("hello");
12
    auto f2 = std::async(std::launch::async,
13
                         [](const std::string& s) { return s.size(); },
14
                         std::cref(big));
15
    std::cout << f2.get() << std::endl;   // 5
16
    // 不指定策略（默认策略）
17
    auto f3 = std::async([] { return 3.14; });
18
    std::cout << f3.get() << std::endl;   // 3.14
19
}

1
#include <future>
2
#include <thread>
3
#include <chrono>
4
#include <iostream>
5
int main() {
6
    // 1. 创建一个"承诺"
7
    std::promise<int> pr;
8
    // 2. 拿到它配套的"未来结果"
9
    auto fut = pr.get_future();
10
    // 3. 把 promise 交给工作线程
11
    //    ⚠️ promise 不可拷贝！只能传引用（或者用 std::move 转移所有权）
12
    std::thread worker([&pr] {
13
        std::this_thread::sleep_for(std::chrono::milliseconds(200));  // 模拟耗时计算
14
        pr.set_value(12345);        // 4. 兑现承诺：把结果写进共享状态
15
        // 注意：set_value 之后，工作线程还能继续干别的活！
16
        std::cout << "[worker] 已兑现承诺" << std::endl;
17
    });
18
    // 5. 主线程阻塞在这里，直到 set_value 被调用（或 promise 析构）
19
    std::cout << "拿到结果：" << fut.get() << std::endl;
20
    worker.join();
21
}

1
#include <future>
2
#include <thread>
3
#include <iostream>
4
#include <stdexcept>
5
int main() {
6
    std::promise<int> pr;
7
    auto fut = pr.get_future();
8
    std::thread worker([&pr] {
9
        try {
10
            throw std::runtime_error("计算失败：数据非法");   // 线程里出了异常
11
        } catch (...) {
12
            // 把"当前异常"打包塞进共享状态，而不是让程序崩掉
13
            pr.set_exception(std::current_exception());
14
        }
15
    });
16
    try {
17
        fut.get();      // 会重新抛出 worker 里设置的那个异常
18
    } catch (const std::exception& e) {
19
        std::cout << "主线程捕获到子线程的异常：" << e.what() << std::endl;
20
    }
21
    worker.join();
22
}

1
#include <future>
2
#include <iostream>
3
int main() {
4
    std::future<int> fut;              // 先声明一个空的 future
5
    {
6
        std::promise<int> pr;          // promise 在花括号作用域内
7
        fut = pr.get_future();         // 把 future 拿出来
8
        // 忘记调用 pr.set_value(...) 就离开了作用域
9
    }                                  // pr 析构 → 共享状态被标记为 broken promise
10
    try {
11
        fut.get();
12
    } catch (const std::future_error& e) {
13
        std::cout << "错误码: " << static_cast<int>(e.code().value()) << std::endl;
14
        std::cout << "错误信息: " << e.what() << std::endl;   // 通常含 "broken promise"
15
    }
16
}

1
#include <future>
2
#include <thread>
3
#include <iostream>
4
int add(int a, int b) { return a + b; }
5
int main() {
6
    // 1. 把函数 add 打包成"任务"，签名是 int(int, int)
7
    std::packaged_task<int(int, int)> task(add);
8
    // 2. 提前拿好它的 future
9
    auto fut = task.get_future();
10
    // 3. 任务不可拷贝，用 std::move 移进线程执行；参数 3 和 4 会传给 add
11
    std::thread t(std::move(task), 3, 4);
12
    // 4. 主线程等结果——包装好的任务执行完会自动存入，无需手动 set_value
13
    std::cout << fut.get() << std::endl;   // 7
14
    t.join();
15
}

1
#include <future>
2
#include <iostream>
3
int main() {
4
    std::packaged_task<int(int)> task([](int n) { return n * n; });
5
    // 第一次执行
6
    auto fut1 = task.get_future();
7
    task(4);
8
    std::cout << "第一轮: " << fut1.get() << std::endl;   // 16
9
    // ⚠️ 不 reset 直接再执行会怎样？—— get_future() 只能调一次，且共享状态已"用完"，
10
    // 再调用 task(5) 时行为未定义/报错。正确的复用方式是 reset()：
11
    task.reset();                 // 绑定一块全新的共享状态，任务又能执行了
12
    auto fut2 = task.get_future();
13
    task(6);
14
    std::cout << "第二轮: " << fut2.get() << std::endl;   // 36
15
}

1
#include <future>
2
#include <thread>
3
#include <iostream>
4
#include <vector>
5
int main() {
6
    // 生成器：一个"广播"的 promise（这里刻意不用 async，演示手动控制"广播时机"）
7
    std::promise<int> pr;
8
    std::shared_future<int> sf = pr.get_future().share();   // future → shared_future
9
    // 3 个消费者线程，每个都"拷贝一份" shared_future（拷贝很廉价，只是引用计数+1）
10
    std::vector<std::thread> consumers;
11
    for (int i = 1; i <= 3; ++i) {
12
        consumers.emplace_back([sf, i] {        // sf 按值捕获：共享同一份结果
13
            std::cout << "消费者 " << i << " 拿到 " << sf.get() << std::endl;
14
        });
15
    }
16
    // 等所有消费者进入等待状态（演示用，实际可省略：等待本身是幂等的）
17
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
18
    pr.set_value(888);                         // 生产者发放结果：一处 set，全部唤醒
19
    std::cout << "生产者已发放 888" << std::endl;
20
    for (auto& t : consumers) t.join();
21
}

1
#include <future>
2
#include <thread>
3
#include <chrono>
4
#include <iostream>
5
int main() {
6
    auto fut = std::async(std::launch::async, [] {
7
        std::this_thread::sleep_for(std::chrono::seconds(1));   // 模拟耗时 1 秒
8
        return 100;
9
    });
10
    // 每 200ms 查看一次，最多查 10 次（即最多等 2 秒）
11
    for (int i = 1; i <= 10; ++i) {
12
        auto status = fut.wait_for(std::chrono::milliseconds(200));
13
        if (status == std::future_status::ready) {
14
            std::cout << "任务完成！结果 = " << fut.get() << std::endl;
15
            return 0;
16
        }
17
        std::cout << "第 " << i << " 次检查：还没好，主线程继续干别的…" << std::endl;
18
    }
19
    std::cout << "等了 2 秒还没完，放弃" << std::endl;
20
}

1
#include <future>
2
#include <chrono>
3
#include <iostream>
4
int main() {
5
    auto fut = std::async(std::launch::async, [] {
6
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
7
        return 1;
8
    });
9
    // 等到"现在 + 2 秒"这个绝对时刻；如果是 ready（提前完成）就直接判定成功
10
    auto status = fut.wait_until(std::chrono::steady_clock::now()
11
                                 + std::chrono::seconds(2));
12
    if (status == std::future_status::ready) {
13
        std::cout << "2 秒内完成了，结果 = " << fut.get() << std::endl;
14
    } else {
15
        std::cout << "到 2 秒还没完成" << std::endl;
16
    }
17
}

1
#include <future>
2
#include <vector>
3
#include <numeric>      // std::iota
4
#include <algorithm>    // std::min
5
#include <iostream>
6
// 把 [begin, end) 范围内的元素加起来（每份任务单独执行）
7
long long sum_range(const std::vector<int>& data, size_t begin, size_t end) {
8
    long long total = 0;
9
    for (size_t i = begin; i < end; ++i) {
10
        total += data[i];
11
    }
12
    return total;
13
}
14
int main() {
15
    const size_t N = 1000000;              // 100 万个整数：1..1000000
16
    std::vector<int> data(N);
17
    std::iota(data.begin(), data.end(), 1);   // 填入 1, 2, 3, ..., 1000000
18
    const size_t chunk = 100000;           // 每份 10 万个数
19
    std::vector<std::future<long long>> futures;
20
    // 把大任务切成 10 份，每份用 launch::async 明确要求"开新线程"并行计算
21
    for (size_t i = 0; i < N; i += chunk) {
22
        futures.push_back(
23
            std::async(std::launch::async,
24
                       sum_range,                       // 函数
25
                       std::cref(data),                 // 参数1：按引用传（避免拷贝）
26
                       i,                               // 参数2：开始下标
27
                       std::min(i + chunk, N)));        // 参数3：结束下标
28
    }
29
    // 汇总：每个 future 依次 get()，得到一个总结果
30
    long long total = 0;
31
    for (auto& f : futures) {
32
        total += f.get();
33
    }
34
    std::cout << "1+2+...+1000000 = " << total << std::endl;   // 500000500000
35
}

1
#include <future>
2
#include <thread>
3
#include <deque>
4
#include <mutex>
5
#include <condition_variable>
6
#include <iostream>
7
#include <vector>
8
// 任务类型：返回 int 的可执行单元，被打包后可以排队执行
9
using Task = std::packaged_task<int()>;
10
int main() {
11
    std::deque<Task> tasks;        // 任务队列
12
    std::mutex m;                  // 保护队列的锁
13
    std::condition_variable cv;    // 通知"有新任务"的条件变量
14
    bool done = false;             // 是否还要继续干活
15
    // 工作线程：循环取任务执行，队列空且被通知结束时退出
16
    std::thread worker([&] {
17
        while (true) {
18
            Task task;
19
            {
20
                // 1. 加锁；2. 等待直到"结束 或 有任务"；3. 拿任务（移走，不拷贝）
21
                std::unique_lock<std::mutex> lock(m);
22
                cv.wait(lock, [&] { return done || !tasks.empty(); });
23
                if (done && tasks.empty()) {
24
                    return;                    // 收工：没有任务也没人说继续
25
                }
26
                task = std::move(tasks.front());
27
                tasks.pop_front();
28
            }
29
            task();                            // 4. 在锁外执行任务（重要！）
30
        }
31
    });
32
    // 主线程：投递 5 个任务
33
    std::vector<std::future<int>> results;
34
    for (int i = 1; i <= 5; ++i) {
35
        Task task([i] { return i * i; });      // 打包
36
        results.push_back(task.get_future());  // 记录结果入口
37
        {
38
            std::lock_guard<std::mutex> lock(m);
39
            tasks.push_back(std::move(task));  // 入队（只移动，不拷贝）
40
        }
41
        cv.notify_one();                       // 喊工作线程起来干活
42
    }
43
    // 通知收工
44
    {
45
        std::lock_guard<std::mutex> lock(m);
46
        done = true;
47
    }
48
    cv.notify_one();
49
    worker.join();
50
    // 汇总所有结果（顺序与投递顺序一致）
51
    for (auto& f : results) {
52
        std::cout << f.get() << ' ';
53
    }
54
    std::cout << std::endl;
55
}