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