C++11相比之前的版本具有很多優秀的特性，比如lambda表示式，初始化列表，右值引用，自動型別推導。同時，C++11標準庫現在也支援正則表示式、智慧指標、多執行緒庫。

但現代C++在並行和非同步計算方面依然較為薄弱，特別是與C#等語言相比。

非同步的需要

為什麼需要支援非同步呢？多核處理器幾乎無處不在、並在雲中分佈的核，使得計算機體系結構變得越來越並行化和分散式化。軟體程式往往越來越多的由使用了位於單個機器或跨網路的多個核的各元件組成。現代程式語言需要提供對這種並行的支援。

同時，響應性（這是響應式程式設計的原則之一）已成為越來越不可或缺的軟體質量。

響應性的意思是在進行IO操作時不是阻塞住等待它的完成。在伺服器端不阻塞一個worker執行緒、而讓它繼續做其他的事情，待操作完成後等待下一個任務。在客戶端不阻塞主執行緒或GUI執行緒，否則將使程式變得反應遲鈍。因此能寫非同步程式碼對於管理IO操作的延遲越來越重要。例如，在WinRT中有一個規則，所有耗時超過50ms的IO密集型API只提供非同步介面，甚至沒有傳統的阻塞式介面可呼叫。

接下來我們看下C++目前提供的支援並行程式設計的方法，這些方法又有什麼新特點。我們可以看到標準方法，以及微軟提供的windows特定的PPL框架。

簡單示例

為了便於理解在C++中如何寫非同步程式碼，我們先寫一個簡單的示例：讀一個檔案，將其內容寫到另一個檔案中。

#include <string> 
#include <vector> 
#include <fstream> 
#include <iostream> 
using namespace std; 

vector<char> readFile(const
 
 string& inPath) 
{ 
    ifstream file(inPath, ios::binary | ios::ate); 
    size_t length = (size_t)file.tellg(); 
    vector<char> buffer(length); 
    file.seekg(0, std::ios::beg); 
    file.read(&buffer[0], length); 
    return buffer; 
} 

size_t writeFile(const vector<char>& buffer, const
 
 string& outPath) 
{ 
    ofstream file(outPath, ios::binary); 
    file.write(&buffer[0], buffer.size()); 
    return (size_t)file.tellp(); 
} 

由上述函式可以寫一個簡單的函式實現複製一個檔案的內容到另一個檔案中，並返回字元數目：

size_t sync_copyFile(const string& inFile, const string& outFile) 
{ 
    return writeFile(readFile(inFile), outFile); 
} 

顯然，我們希望依次執行readFile和writelFile函式。但是有必要阻塞的等待它們完成嗎？當然，這是一個人為的例子，如果檔案不是很大這一點可能無關緊要，如果檔案很大，我們可以使用快取及塊拷貝的方法代替將檔案內容填充到很大的vector返回。但是readFile和writeFile都是IO密集函式，在這裡只表示一種更復雜IO操作的模式。在真實程式中從網路中讀取資料、經過轉換後返回或寫入是很普遍的。

讓我們看看在標準C++中如何實現非同步執行copyFile操作。

基於任務的並行：future和promise

C++標準庫提供了一些支援併發的機制。首先是std::thread，以及相關的同步用物件（std::mutex, std::lock_guards, std::condition_variables等），最終提供了可寫“傳統的”基於多執行緒併發程式碼的便捷方法。

我們需要修改copyFile：建立一個新執行緒執行拷貝操作，並在執行緒執行完成後使用condition_variable進行通知。但是使用執行緒和鎖進行操作比較複雜麻煩。現代框架（例如.net中的TPL）以基於任務（task）的併發方式提供了更高階的抽象。一個task代表了一個可以與其他操作並行執行的非同步操作，系統隱藏了其實現的具體細節。

C++11標準庫標頭檔案也以promise和future提供對基於task並行的（有限地）支援。類std::promise和std::future類比.net中的Task、或者Java8中的Future。這兩個類總是成對出現，將呼叫函式與獲取執行結果分離開來。

當我們呼叫非同步函式時呼叫方並不是得到型別T的結果，而是一個std::future物件，這是一個將在未來某個時間點返回結果的佔位符。

一旦獲得future，我們可以繼續做其他事情，同時非同步任務也在一個獨立的執行緒中執行。

std::promise物件代表非同步呼叫被呼叫方的執行結果，這是一個將非同步結果傳給呼叫方的通道。當任務完成後，被呼叫方通過呼叫promise::set_value將結果賦給一個promise物件。

當呼叫方最後需要結果時可呼叫阻塞函式future::get()即可獲得。如果任務已經完成，結果可被立即使用，否則，呼叫執行緒將被掛起直到結果可用。

上述copyFile使用future和promise修改後的版本：

#include <future> 

size_t future_copyFile(const string& inFile, const string& outFile) 
{ 
    std::promise<vector<char>> prom1; 
    std::future<vector<char>> fut1 = prom1.get_future(); 
    std::thread th1([&prom1, inFile](){ 
        prom1.set_value(readFile(inFile)); 
    }); 

    std::promise<int> prom2; 
    std::future<int> fut2 = prom2.get_future(); 
    std::thread th2([&fut1, &prom2, outFile](){ 
        prom2.set_value(writeFile(fut1.get(), outFile)); 
    }); 

    size_t result = fut2.get(); 
    th1.join(); 
    th2.join(); 
    return result; 
} 

注意到我們將readFile和writeFile的執行移動到了單獨的task中，但是我們仍然需要設定、啟動執行緒執行它們。並且，在lambda表示式中捕獲了需要的promise和future物件，以便可以在lambda表示式中直接使用。第一個執行緒執行讀操作，當讀完成時將結果填入vector型別的promise中。第二個執行緒阻塞地等待，當第一個執行緒讀操作完成時，結果會傳入此執行緒的寫函式中。最後，寫操作完成時，寫的字元數填入第二個future中。

主執行緒可以有效利用這種並行，在呼叫future::get()獲得最終結果之前可以做其他的事情。當然，當呼叫future::get()時如果讀寫操作還未完成，主執行緒還是會阻塞。

Packaged tasks

可以用packaged_task稍微簡化上述程式碼。類std::packaged_task 是一個task及其promise的容器。它的模板型別T是一個任務函式型別（例如，對於上面的readFile函式，T就是vector(const string&) ）。它是一個可呼叫型別（定義了operator()），併為我們自動建立和管理了一個std::promise物件。

size_t packagedtask_copyFile(const string& inFile, const string& outFile) 
{ 
    using Task_Type_Read = vector<char>(const string&); 
    packaged_task<Task_Type_Read> pt1(readFile); 
    future<vector<char>> fut1{ pt1.get_future() }; 
    thread th1{ move(pt1), inFile }; 

    using Task_Type_Write = size_t(const string&); 
    packaged_task<Task_Type_Write> pt2([&fut1](const string& path){ 
        return writeFile(fut1.get(), path); 
    }); 
    future<size_t> fut2{ pt2.get_future() }; 
    thread th2{ move(pt2), outFile }; 

    size_t result = fut2.get(); 
    th1.join(); 
    th2.join(); 
    return result; 
} 

（譯者注：promise封裝的是資料型別，packaged_task封裝的是可呼叫物件，兩者都有get_future()介面獲得future物件）

注意到需要使用move()函式傳遞packaged_task給執行緒，因為packaged_task型別無法被拷貝。

std::async

使用packaged_task後代碼沒有改變多少，稍微好讀了一些，但是我們仍然需要手動建立執行緒、決定task執行在哪個執行緒中。

如果我們使用標準庫中的std::async函式，一切會變得非常簡單。傳入一個lambda或functor，std::async會返回包含執行結果值的future。copyFile函式用std::async()修改後的版本如下：

size_t async_copyFile(const string& inFile, const string& outFile) 
{ 
    auto fut1 = async(readFile, inFile); 
    auto fut2 = async([&fut1](const string& path){ 
        return writeFile(fut1.get(), path); 
    }, 
    outFile); 

    return fut2.get(); 
} 

從某種程度上來說std::async()相當於TPL任務排程。它會決定在哪個執行緒中執行任務，或在新建立的新執行緒中，或在重複使用的老執行緒中。

也可以通過第二個引數決定啟動策略，“async”表示立即非同步地執行任務，可能是在不同的執行緒中，“deferred”表示只有在get()被呼叫的時候才開始執行任務。

std::async的優點是隱藏了所有的實現、平臺相關的細節。檢視vs2013中標頭檔案，可以看到其在windows平臺下的實現，內部使用了相當於.NET TPL的PPL（Parallel Patterns Library）。

PPL

上面看到的都是C++11標準化的內容。客觀上來說future和promise的使用依然是有限的，特別是跟C#和.net相比。

主要的限制是在C++11中future不是可組合的（composable）。如果啟動多個task平行計算，我們無法實現阻塞所有的future、等待其中任意一個完成，但在某一刻只有一個future返回。同樣，也沒有好的方法將一組task組合成一個序列，每個task的結果作為下一個task的輸入。可組合task可以使整個體系結構非阻塞且事件驅動。真的希望C++中也有類似任務延續（task continuations）或async/await的模式。

有了PPL（又名Concurrency Runtime）微軟有可能突破標準的束縛，嘗試task庫的更復雜的實現。

在PPL中，類Concurrency::task（定義在< ppltasks.h>標頭檔案中）代表了一個task。一個task等價於一個future。同時也提供了相同的阻塞方法以獲取結果——get()。模板引數T表示返回型別，task進行初始化時將工作函式傳入其中（lambda表示式、函式指標或函式物件）。

下面暫時不考慮可移植性，重新實現copyFile函式：

size_t ppl_copyFile(const string& inFile, const string& outFile) 
{ 
    Concurrency::task<vector<char>> tsk1 = Concurrency::create_task([inFile]() { 
        return readFile(inFile); 
    }); 
    Concurrency::task<size_t> tsk2 = Concurrency::create_task([&tsk1, outFile]() { 
        return writeFile(tsk1.get(), outFile); 
    }); 
    return tsk2.get(); 
} 

此處建立了2個task物件，由兩個lambda表示式進行初始化，分別表示讀和寫操作。

現在我們真正不用考慮執行緒問題了。由PPL排程來決定在哪執行task、如何管理一個執行緒池。要注意我仍然要手動地協調兩個task之間的相互作用關係：task2擁有task1的引用，明確地等待task1結束後再使用其結果。這在像這種簡單例子中是可以接受的，但如果是更多task、更復雜的程式碼，這將會變得非常繁瑣。

任務延續（Task continuations）

與future不同，PPL的task支援通過延續來進行組合。task::next方法可以將一個個task延續起來。當前序task完成時將返回其結果並呼叫後續task。

這次使用任務延續重寫copyFile：

size_t ppl_then_copyFile(const string& inFile, const string& outFile) 
{ 
    Concurrency::task<size_t> result =  
    Concurrency::create_task([inFile]() { 
        return readFile(inFile); 
    }).then([outFile](const vector<char>& buffer) { 
        return writeFile(buffer, outFile); 
    }); 

    return result.get(); 
} 

這段程式碼非常簡潔。我們把copy函式的邏輯拆分成兩個獨立的、可以執行在任意執行緒的部分（task），並被一個task排程程式執行。

上述copyFile的實現仍然會在最後處阻塞以獲得最終結果，但在一個真實的程式中可以僅返回task物件，插入到程式邏輯中，新增到一個任務延續中非同步操作其結果。例如：

Concurrency::task<size_t> ppl_create_copyFile_task(const string& inFile, const string& outFile) 
{ 
    return Concurrency::create_task([inFile]() { 
        return readFile(inFile); 
    }).then([outFile](const vector<char>& buffer) { 
        return writeFile(buffer, outFile); 
    }); 
} 
... 
auto tCopy = ppl_create_copyFile_task(inFile, outFile).then([](size_t written) { 
    cout << written << endl; 
}); 
... 
tCopy.wait(); 

PPL同時還提供了其他方法來組合任務，task::wait_all和task::wait_any，對管理並行執行的一組任務很有幫助。

對於一組task，when_all會在所有task完成後建立另一個task（內部實現了join）。相反，when_any會在任意一個task完成時建立一個另一個task，這在有些地方是很有用的，比如要限制task的並行數量、只有在一個task完成後才開始一個新task。

以上只是PPL的冰山一角。PPL提供了非常豐富的函式集，幾乎與其託管版本相當。還提供了一些排程類，用於實現管理工作執行緒池、分配task到執行緒中等重要任務。詳細請見此處。

C++17前瞻

很快我們有希望在C++標準中見到上面介紹的一些PPL中的實現。這裡已經有一份Niklas Gustaffson等人寫的檔案N3857，它提出了一些標準的變化。特別地，提供了 future::then, future::when_any and future::when_all實現future的可組合，這同PPL有著相同的語義。對於之前的例子，用新的future可以很方便的寫成如下程式碼：

future<size_t> future_then_copyFile(const string& inFile, const string& outFile)
{
    return async([inFile]() {
        return readFile(inFile);
    }).then([outFile](const vector<char>& buffer) {
        return writeFile(buffer, outFile);
    });
}

還有函式 future::is_ready用於在呼叫阻塞函式get()之前先測試future是否已完成，future::unwrap用於管理巢狀future（future返回的還是future）。當然，此方案的所有細節都可以在上述提供的檔案中找到。

這就是完美解決方案了？不完全是。在.net中的經驗告訴我們基於task的非同步程式碼仍然很難編寫、除錯、維護。有時候非常困難。這就是為什麼為了通過async/await模式更方便的管理非同步任務，添加了一些新關鍵詞到C# 5.0中。在C++世界是否有類似的方法呢？