【C++并发编程】std::future、std::async、std::packaged_task与std::promise的深度探索（二）

#include <algorithm>
#include <future>
#include <vector>
template <typename T>
void parallel_sort(std::vector<T>& v) {
    if (v.size() <= 10000) {  // 对于小数组，直接排序
        std::sort(v.begin(), v.end());
    } else {  // 对于大数组，分成两半并行排序
        std::vector<T> v1(v.begin(), v.begin() + v.size() / 2);
        std::vector<T> v2(v.begin() + v.size() / 2, v.end());
        std::future<void> fut = std::async([&v1] { parallel_sort(v1); });
        parallel_sort(v2);
        fut.get();
        std::merge(v1.begin(), v1.end(), v2.begin(), v2.end(), v.begin());
    }
}

#include <future>
#include <iostream>
#include <string>
std::string download_file(const std::string& url) {
    // 用你的下载库下载文件...
    return "file content";
}
int main() {
    std::future<std::string> fut = std::async(download_file, "http://example.com/file");
    // 在此处执行其他任务...
    std::string file_content = fut.get();
    std::cout << "Downloaded file content: " << file_content << "\n";
    return 0;
}

#include <future>
#include <iostream>
#include <string>
#include <vector>
void write_log(const std::string& log) {
    // 在这里写入日志，例如：
    std::cout << "Writing log: " << log << std::endl;
}
std::future<void> log_async(const std::string& log) {
    return std::async(std::launch::async, write_log, log);
}
int main() {
    std::vector<std::future<void>> futures;
    futures.push_back(log_async("Start program"));
    // 执行其他任务...
    futures.push_back(log_async("End program"));
    // 等待所有异步日志任务完成
    for (auto& future : futures) {
        future.get();
    }
    return 0;
}

#include <future>
#include <iostream>
#include <chrono>
int calculate() {
    // 在这里执行一些复杂的计算...
    return 42;
}
int main() {
    std::future<int> fut = std::async(std::launch::async, calculate);
    std::chrono::milliseconds span(100);  // 最多等待100毫秒
    if (fut.wait_for(span) == std::future_status::ready) {
        int result = fut.get();
        std::cout << "Result is " << result << "\n";
    } else {
        std::cout << "Calculation did not finish in time\n";
    }
    return 0;
}

// 创建一个 packaged_task，它将 std::plus<int>() 封装起来
std::packaged_task<int(int, int)> task(std::plus<int>());
// 获取与 task 关联的 future
std::future<int> result_future = task.get_future();
// 在另一个线程中执行 task
std::thread(std::move(task), 5, 10).detach();
// 在原线程中，我们可以从 future 中获取结果
int result = result_future.get();  // result == 15

#include <iostream>
#include <future>
#include <thread>
// 一个要在子线程中执行的函数
int calculate(int x, int y) {
    return x + y;
}
int main() {
    // 创建一个packaged_task，将calculate函数封装起来
    std::packaged_task<int(int, int)> task(calculate);
    // 获取与task关联的future
    std::future<int> result = task.get_future();
    // 创建一个新线程并执行task
    std::thread task_thread(std::move(task), 5, 10);
    
    // 在主线程中，我们可以从future中获取结果
    int result_value = result.get();
    std::cout << "Result: " << result_value << std::endl;  // 输出: Result: 15
    task_thread.join();
    return 0;
}

#include <queue>
#include <future>
#include <mutex>
// 任务队列
std::queue<std::packaged_task<int()>> tasks;
std::mutex tasks_mutex;
// 生产者线程
void producer() {
    // 创建一个packaged_task
    std::packaged_task<int()> task([]() { return 7 * 7; });
    // 将task添加到任务队列中
    std::lock_guard<std::mutex> lock(tasks_mutex);
    tasks.push(std::move(task));
}
// 消费者线程
void consumer() {
    // 从任务队列中取出一个task并执行
    std::lock_guard<std::mutex> lock(tasks_mutex);
    if (!tasks.empty()) {
        std::packaged_task<int()> task = std::move(tasks.front());
        tasks.pop();
        task();
    }
}

// 第一个任务
std::packaged_task<int()> task1([]() { return 7 * 7; });
std::future<int> future1 = task1.get_future();
// 第二个任务，它的输入是第一个任务的结果
std::packaged_task<int(int)> task2([](int x) { return x + 1; });
std::future<int> future2 = task2.get_future();
// 在一个线程中执行第一个任务
std::thread(std::move(task1)).detach();
// 在另一个线程中执行第二个任务
std::thread([&]() {
    task2(future1.get());
}).detach();
// 获取第二个任务的结果
int result = future2.get();

#include <iostream>
#include <future>
#include <thread>
void my_promise(std::promise<int>& p) {
    std::this_thread::sleep_for(std::chrono::seconds(1)); // 模拟一些工作
    p.set_value(42); // 设置值
}
int main() {
    std::promise<int> p;
    std::future<int> f = p.get_future(); // 获取 future
    std::thread t(my_promise, std::ref(p)); // 在新线程中运行函数
    std::cout << "Waiting for the answer...\n";
    std::cout << "The answer is " << f.get() << '\n'; // 获取值
    t.join();
    return 0;
}

#include <iostream>
#include <future>
#include <thread>
// 这个函数将会在一个新线程中被运行
void compute(std::promise<int>& p) {
    int result = 0;
    // 做一些计算...
    for (int i = 0; i < 1000000; ++i) {
        result += i;
    }
    // 计算完成，设置 promise 的值
    p.set_value(result);
}
int main() {
    // 创建一个 promise 对象
    std::promise<int> p;
    // 获取与 promise 关联的 future 对象
    std::future<int> f = p.get_future();
    // 在新线程中运行 compute 函数
    std::thread t(compute, std::ref(p));
    // 在主线程中获取结果
    std::cout << "The result is " << f.get() << std::endl;
    // 等待新线程完成
    t.join();
    return 0;
}

#include <iostream>
#include <future>
#include <thread>
void chain_task(std::future<int>& f, std::promise<int>& p) {
    int input = f.get(); // 获取输入
    int output = input * 2; // 执行一些计算
    p.set_value(output); // 设置输出
}
int main() {
    // 创建 promise 和 future 的链
    std::promise<int> p1;
    std::future<int> f1 = p1.get_future();
    std::promise<int> p2;
    std::future<int> f2 = p2.get_future();
    // 在新线程中运行异步任务
    std::thread t1(chain_task, std::ref(f1), std::ref(p2));
    std::thread t2(chain_task, std::ref(f2), std::ref(p1));
    // 设置初始输入
    p1.set_value(42);
    // 获取最终结果
    std::cout << "The final result is " << f1.get() << std::endl;
    // 等待新线程完成
    t1.join();
    t2.join();
    return 0;
}