「C++黑魔法」future 與 promise：不加鎖的異步編程，原來可以這么簡單！
作者：xiaokang1998
在本文中，我們將探討十個高級C#技巧，這些技巧是為想要突破C#極限的更有經(jīng)驗的開發(fā)人員量身定制的。這些技巧可以提高代碼的性能、可讀性和可維護性。
朋友，想象一下這個場景：你在餐廳點了一份需要20分鐘才能做好的復雜菜品。你有兩個選擇：
- 坐在那里盯著廚房門口，等待20分鐘（同步等待）
- 服務員給了你個取餐碼，菜品好了會通知你，同時你可以刷刷手機或聊聊天（異步等待）
顯然，第二種方式更高效，對吧？
在C++編程中，future和promise就像是這個"取餐碼+通知"系統(tǒng)，讓你的程序能夠優(yōu)雅地處理異步任務。它們是C++11引入的現(xiàn)代并發(fā)編程工具，比傳統(tǒng)的線程、互斥鎖和條件變量更加簡單易用。
一、異步任務是個啥？通俗地說就是"后臺運行"
在解釋future和promise之前，我們先聊聊什么是異步任務。
異步任務就是指那些可以在"后臺"執(zhí)行，不需要主線程等待的任務。比如：
- 下載一個大文件
- 復雜計算（如圖像處理）
- 訪問遠程服務器
想象一下你的電腦在下載游戲的同時，你還能繼續(xù)刷視頻、聊天，這就是異步的魅力！
二、future：未來會得到的結果
future可以理解為"未來的結果"，它就像一張電影票根：
- 你現(xiàn)在拿著票根（future）
- 電影（異步任務）正在后臺準備中
- 當電影準備好了，你可以用票根進場（獲取結果）
用代碼說話：
#include <iostream>
#include <future>
#include <thread>
#include <chrono>
int compute_answer() {
// 假裝這是個復雜計算
std::cout << "開始計算終極問題的答案..." << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(2)); // 模擬耗時操作
std::cout << "計算完成！" << std::endl;
return 42; // 返回結果
}
int main() {
// 啟動異步任務，立即返回一個future
std::cout << "主線程：啟動一個耗時任務" << std::endl;
std::future<int> answer_future = std::async(compute_answer);
std::cout << "主線程：哇，不用等待，我可以繼續(xù)做其他事情！" << std::endl;
// 做一些其他工作...
std::this_thread::sleep_for(std::chrono::seconds(1));
std::cout << "主線程：我在異步任務計算的同時做了些其他事" << std::endl;
// 當需要結果時，我們可以獲取它
// 如果結果還沒準備好，這會阻塞直到結果可用
std::cout << "主線程：好了，現(xiàn)在我需要知道答案了，等待結果..." << std::endl;
int answer = answer_future.get();
std::cout << "終極答案是：" << answer << std::endl;
return 0;
}輸出結果：
主線程：啟動一個耗時任務
開始計算終極問題的答案...
主線程：哇，不用等待，我可以繼續(xù)做其他事情！
主線程：我在異步任務計算的同時做了些其他事
計算完成！
主線程：好了，現(xiàn)在我需要知道答案了，等待結果...
終極答案是：42看到了嗎？主線程啟動了計算，但并不立即等待結果，而是繼續(xù)執(zhí)行其他代碼。只有當真正需要結果時（調用get()），才會等待異步任務完成。
三、promise：我保證會給你結果
如果說future是領取結果的憑證，那么promise就是一個承諾："我保證會在某個時刻設置一個值"。它們是一對好搭檔：
- promise負責在某個時刻設置結果
- future負責在需要時獲取結果
這就像你和朋友的約定：
- 你：我承諾會告訴你考試成績（promise）
- 朋友：我會等你告訴我（future）
來看個例子：
#include <iostream>
#include <future>
#include <thread>
#include <chrono>
void producer(std::promise<int> my_promise) {
std::cout << "生產(chǎn)者：我要開始生產(chǎn)一個重要的值了..." << std::endl;
// 假裝我們在做一些復雜的計算
std::this_thread::sleep_for(std::chrono::seconds(2));
int result = 42;
std::cout << "生產(chǎn)者：計算完成，設置結果到promise" << std::endl;
// 設置promise的值，這會通知相關的future
my_promise.set_value(result);
}
int main() {
// 創(chuàng)建一個promise
std::promise<int> answer_promise;
// 從promise獲取一個future
std::future<int> answer_future = answer_promise.get_future();
// 啟動一個線程，傳入promise
std::cout << "主線程：啟動生產(chǎn)者線程" << std::endl;
std::thread producer_thread(producer, std::move(answer_promise));
// 主線程繼續(xù)做其他事情
std::cout << "主線程：我可以做自己的事，不用等待..." << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(1));
// 當需要結果時
std::cout << "主線程：現(xiàn)在我需要結果了，等待future..." << std::endl;
int answer = answer_future.get();
std::cout << "主線程：收到結果：" << answer << std::endl;
// 別忘了等待線程結束
producer_thread.join();
return 0;
}輸出結果：
主線程：啟動生產(chǎn)者線程
生產(chǎn)者：我要開始生產(chǎn)一個重要的值了...
主線程：我可以做自己的事，不用等待...
主線程：現(xiàn)在我需要結果了，等待future...
生產(chǎn)者：計算完成，設置結果到promise
主線程：收到結果：42這個例子展示了如何使用promise和future在線程間傳遞結果。生產(chǎn)者線程通過promise設置值，主線程通過future獲取值。
四、future的幾種獲取方式
除了通過promise獲取future，C++11還提供了其他便捷方式：
1. 通過async獲取future
std::async是最簡單的方式，它自動創(chuàng)建線程并返回future：
std::future<int> result = std::async([]() {
return 42;
});2. 通過packaged_task獲取future
std::packaged_task包裝了一個可調用對象，并允許你獲取其future：
#include <iostream>
#include <future>
#include <thread>
int main() {
// 創(chuàng)建一個packaged_task，包裝一個lambda函數(shù)
std::packaged_task<int(int, int)> task([](int a, int b) {
std::cout << "計算 " << a << " + " << b << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(1)); // 模擬耗時計算
return a + b;
});
// 獲取future
std::future<int> result = task.get_future();
// 在新線程中執(zhí)行任務
std::thread task_thread(std::move(task), 10, 32);
// 主線程做其他事情...
std::cout << "主線程：等待計算結果..." << std::endl;
// 獲取結果
int sum = result.get();
std::cout << "結果是：" << sum << std::endl;
task_thread.join();
return 0;
}輸出結果：
主線程：等待計算結果...
計算 10 + 32
結果是：42五、實用功能：future的超時等待
有時候，我們不想無限期地等待異步任務。future提供了帶超時的等待功能：
#include <iostream>
#include <future>
#include <chrono>
int long_calculation() {
std::this_thread::sleep_for(std::chrono::seconds(3));
return 42;
}
int main() {
auto future = std::async(std::launch::async, long_calculation);
// 設置1秒超時
auto status = future.wait_for(std::chrono::seconds(1));
if (status == std::future_status::ready) {
std::cout << "任務已完成，結果是：" << future.get() << std::endl;
} elseif (status == std::future_status::timeout) {
std::cout << "等待超時！任務還沒完成" << std::endl;
// 我們仍然可以繼續(xù)等待完成
std::cout << "繼續(xù)等待..." << std::endl;
std::cout << "最終結果：" << future.get() << std::endl;
}
return 0;
}輸出結果：
等待超時！任務還沒完成
繼續(xù)等待...
最終結果：42六、異常處理：當異步任務出錯時
異步任務中的異常會被捕獲并存儲在future中，當你調用get()時會重新拋出：
#include <iostream>
#include <future>
#include <stdexcept>
int may_throw() {
std::this_thread::sleep_for(std::chrono::seconds(1));
throw std::runtime_error("哎呀，出錯了！");
return 42;
}
int main() {
auto future = std::async(may_throw);
try {
int result = future.get();
std::cout << "結果：" << result << std::endl;
} catch (conststd::exception& e) {
std::cout << "捕獲到異常：" << e.what() << std::endl;
}
return 0;
}輸出結果：
捕獲到異常：哎呀，出錯了！這種設計非常優(yōu)雅——無論異步任務是成功返回值還是拋出異常，都能通過同一個future接口處理。
七、實際應用案例：并行計算求和
讓我們用一個更實用的例子來鞏固理解：并行計算大數(shù)組的和。
#include <iostream>
#include <vector>
#include <numeric>
#include <future>
#include <chrono>
// 計算數(shù)組部分和的函數(shù)
long long partial_sum(const std::vector<int>& data, size_t start, size_t end) {
returnstd::accumulate(data.begin() + start, data.begin() + end, 0LL);
}
int main() {
// 創(chuàng)建一個大數(shù)組
const size_t size = 100000000; // 1億個元素
std::vector<int> data(size, 1); // 全是1的數(shù)組
auto start_time = std::chrono::high_resolution_clock::now();
// 單線程計算
long long single_result = std::accumulate(data.begin(), data.end(), 0LL);
auto single_end = std::chrono::high_resolution_clock::now();
auto single_duration = std::chrono::duration_cast<std::chrono::milliseconds>(single_end - start_time);
std::cout << "單線程結果: " << single_result << " (耗時: "
<< single_duration.count() << "ms)" << std::endl;
// 使用4個線程并行計算
auto multi_start = std::chrono::high_resolution_clock::now();
const size_t num_threads = 4;
const size_t block_size = size / num_threads;
std::vector<std::future<long long>> futures;
for (size_t i = 0; i < num_threads; ++i) {
size_t start = i * block_size;
size_t end = (i == num_threads - 1) ? size : (i + 1) * block_size;
// 啟動異步任務
futures.push_back(std::async(std::launch::async,
partial_sum, std::ref(data), start, end));
}
// 收集結果
long long multi_result = 0;
for (auto& f : futures) {
multi_result += f.get();
}
auto multi_end = std::chrono::high_resolution_clock::now();
auto multi_duration = std::chrono::duration_cast<std::chrono::milliseconds>(multi_end - multi_start);
std::cout << "多線程結果: " << multi_result << " (耗時: "
<< multi_duration.count() << "ms)" << std::endl;
std::cout << "加速比: " << static_cast<double>(single_duration.count()) / multi_duration.count() << "x" << std::endl;
return 0;
}可能的輸出結果（取決于你的硬件）：
單線程結果: 100000000 (耗時: 570ms)
多線程結果: 100000000 (耗時: 171ms)
加速比: 3.33333x看到?jīng)]？多線程版本明顯更快！這正是future的價值所在——讓并行編程變得簡單而高效。
八、總結：為什么future和promise這么香？
現(xiàn)在，你已經(jīng)了解了C++11中future和promise的基本用法。它們的優(yōu)勢在于：
- 簡化異步編程：比直接管理線程、互斥鎖和條件變量簡單得多
- 清晰的所有權模型：promise負責生產(chǎn)值，future負責消費值
- 異常傳遞：異步任務中的異常會自動傳遞給等待的future
- 超時控制：可以設置等待超時，避免無限阻塞
與現(xiàn)代C++完美融合：配合lambda、智能指針等現(xiàn)代特性使用更加優(yōu)雅
記住這個類比就行：promise就像一個"承諾給你結果的人"，future就像"等待結果的憑證"。
下次當你需要在程序中執(zhí)行耗時操作又不想阻塞主線程時，就想到future和promise吧！它們會讓你的代碼更加現(xiàn)代、高效，還能充分利用多核處理器的威力。
最后一個小提示：雖然C++11的future和promise已經(jīng)很強大，但如果你追求更高級的異步編程，可以考慮看看C++20的協(xié)程(coroutine)特性，那又是另一個讓人興奮的話題了～
責任編輯：趙寧寧
來源：
跟著小康學編程
