C++11实用技术（三）std::future、std::promise、std::packaged_task、async

#include <iostream>
#include <thread>
// 线程函数，打印一条消息
void printMessage(const std::string& message) {
    std::cout << "Message: " << message << std::endl;
}
int main() {
    // 创建线程对象，并指定线程函数及其参数
    std::thread t(printMessage, "Hello, world!");
    // 等待线程执行完毕
    t.join();
    return 0;
}

#include <iostream>
#include <future>
int calculateSum(int a, int b) {
    return a + b;
}
int main() {
    std::future<int> result = std::async(calculateSum, 2, 3);
    // 执行其他操作...
    // 获取异步任务的结果
    int sum = result.get();
    // 输出结果
    std::cout << "Sum: " << sum << std::endl;
    return 0;
}

std::future<int> result = std::async(std::launch::async, calculateSum, 2, 3);
std::future<int> result = std::async(std::launch::deferred, calculateSum, 2, 3);

#include <iostream>
#include <future>
int calculateSum(int a, int b) {
  return a + b;
}
int main() {
  std::future<int> result = std::async(calculateSum, 2, 3);
  // 执行其他操作...
  // 获取异步任务的结果
  int sum = result.get();
  // 输出结果
  std::cout << "Sum: " << sum << std::endl;
  int sum1 = result.get();//这里第二次使用get会报错
  return 0;
}

#include <iostream>
#include <future>
// 异步任务函数，返回一个结果
int asyncTask() {
  // 模拟耗时操作
  std::this_thread::sleep_for(std::chrono::seconds(5));
  return 42;
}
int main() {
  // 创建异步任务，并获取 std::future 对象
  std::future<int> fut = std::async(std::launch::async, asyncTask);
  // 创建共享的 std::shared_future 对象
  std::shared_future<int> sharedFut = fut.share();
  // 在多个线程中获取共享的异步任务结果
  std::thread t1([&sharedFut]() {
    int result = sharedFut.get();
    std::cout << "Thread 1 Result: " << result << std::endl;
    });
  std::thread t2([&sharedFut]() {
    int result = sharedFut.get();
    std::cout << "Thread 2 Result: " << result << std::endl;
    });
  t1.join();
  t2.join();
  return 0;
}

#include <iostream>
#include <future>
void calculateSum(std::promise<int>& promise, int a, int b) {
    int sum = a + b;
    // 设置值
    promise.set_value(sum);
}
int main() {
    std::promise<int> promise;
    std::future<int> result = promise.get_future();
    // 启动异步任务
    std::thread thread(calculateSum, std::ref(promise), 2, 3);//这里用std::async也是一样的，但这里我们不需要获取task的返回值，所以就使用thread。
    // 执行其他操作...
    // 获取异步任务的结果
    int sum = result.get();
    // 输出结果
    std::cout << "Sum: " << sum << std::endl;
    // 等待线程结束
    thread.join();
    return 0;
}

#include <iostream>
#include <future>
int calculateSum(int a, int b) {
    return a + b;
}
int main() {
    std::packaged_task<int(int, int)> task(calculateSum);
    std::future<int> result = task.get_future();
    // 启动异步任务
    std::thread thread(std::move(task), 2, 3);
    // 执行其他操作...
    // 获取异步任务的结果
    int sum = result.get();
    // 输出结果
    std::cout << "Sum: " << sum << std::endl;
    // 等待线程结束
    thread.join();
    return 0;
}