5分鍾速成C++14多線程編程

原文鏈接：Learn C++ Multi-Threading in 5 Minutes

　　C++14的新的多線程架構非常簡單易學，如果你對C或者C++很熟悉，那么本文非常適合你。作者用C++14作為基准參考，但是所介紹的東西在C++17中也依然適用。本文只介紹基本的架構，在讀完本文后你應該也可以自己編寫自己的多線程程序。

創建線程

創建線程有以下幾種方式：

1.使用函數指針

2.使用仿函數

3.使用lambda表達式

這些方式都比較類似，只有部分差別，我將在下面具體講述每一種方式和他們的區別。

使用函數指針

　　來看看下面這個函數，其參數包括一個vector的引用 v ，一個輸出結果的引用acm，還有兩個v的索引。這個函數會將v的beginIndex和endIndex之間的元素累加起來。

void accumulator_function2(const std::vector<int> &v, unsigned long long &acm, 
                            unsigned int beginIndex, unsigned int endIndex)
{
    acm = 0;
    for (unsigned int i = beginIndex; i < endIndex; ++i)
    {
        acm += v[i];
    }
}

　　現在如果我們想將vector分為兩個部分，並在單獨的線程t1和t2中分別計算各部分的總和的話，我們可以這么寫：

//Pointer to function
    {
        unsigned long long acm1 = 0;
        unsigned long long acm2 = 0;
        std::thread t1(accumulator_function2, std::ref(v), 
                        std::ref(acm1), 0, v.size() / 2);
        std::thread t2(accumulator_function2, std::ref(v), 
                        std::ref(acm2), v.size() / 2, v.size());
        t1.join();
        t2.join();

        std::cout << "acm1: " << acm1 << endl;
        std::cout << "acm2: " << acm2 << endl;
        std::cout << "acm1 + acm2: " << acm1 + acm2 << endl;
    }

上面這段你需要知道：

　　1.std::thread這個調用創建了一個新的線程。其第一個參數是函數指針 accumulator_function2 ，因此每個線程都會去執行這個函數。

　　2.剩下的我們傳給std::thread的構造函數的參數，都是我們需要去傳給accumulator_function2的參數。

　　3.重點：傳遞給accumulator_function2的參數默認情況下都是值傳遞的，除非你用std::ref把他包起來。所以我們這里使用了std::ref來包住v、acm1、acm2。

　　4.使用std::thread創建的線程是沒有返回值的，所以如果你想從線程中返回些什么，請使用引用將你想返回的值作為一個傳入參數。這里的例子就是acm1和acm2。

　　5.每個線程一旦創建就立即執行了。

　　6.我們使用join()函數來等待線程執行完畢。

使用偽函數

　　你也可以使用偽函數來做同樣的事情，下面是例子：

class CAccumulatorFunctor3
{
  public:
    void operator()(const std::vector<int> &v, 
                    unsigned int beginIndex, unsigned int endIndex)
    {
        _acm = 0;
        for (unsigned int i = beginIndex; i < endIndex; ++i)
        {
            _acm += v[i];
        }
    }
    unsigned long long _acm;
};

　　那么創建線程的方式變成下面這樣：

//Creating Thread using Functor
    {

        CAccumulatorFunctor3 accumulator1 = CAccumulatorFunctor3();
        CAccumulatorFunctor3 accumulator2 = CAccumulatorFunctor3();
        std::thread t1(std::ref(accumulator1), 
            std::ref(v), 0, v.size() / 2);
        std::thread t2(std::ref(accumulator2), 
            std::ref(v), v.size() / 2, v.size());
        t1.join();
        t2.join();

        std::cout << "acm1: " << accumulator1._acm << endl;
        std::cout << "acm2: " << accumulator2._acm << endl;
        std::cout << "accumulator1._acm + accumulator2._acm : " << 
            accumulator1._acm + accumulator2._acm << endl;
    }

上面這段你需要知道：

　　偽函數的使用方式大部分地方都和函數指針很像，除了：

　　1.第一個參數變成了偽函數對象。

　　2.我們不再需要使用引用來獲取返回值了，我們可以將返回值作為偽函數對象的一個成員變量來儲存。這里的例子就是_acm。

使用lambda表達式

　　作為第三種選擇，我們可以在每個線程的構造函數中使用lambda表達式來定義我們想做的事，如下：

{
        unsigned long long acm1 = 0;
        unsigned long long acm2 = 0;
        std::thread t1([&acm1, &v] {
            for (unsigned int i = 0; i < v.size() / 2; ++i)
            {
                acm1 += v[i];
            }
        });
        std::thread t2([&acm2, &v] {
            for (unsigned int i = v.size() / 2; i < v.size(); ++i)
            {
                acm2 += v[i];
            }
        });
        t1.join();
        t2.join();

        std::cout << "acm1: " << acm1 << endl;
        std::cout << "acm2: " << acm2 << endl;
        std::cout << "acm1 + acm2: " << acm1 + acm2 << endl;
    }

同樣，大多數地方都和函數指針的方式很類似，除了：

　　1.作為傳參的替代方式，我們可以使用lambda表達式的捕獲(capture)方式來處理參數傳遞

Tasks, Futures, and Promises

除了std::thread，我們還可以使用 tasks.

tasks和std::thread工作的方式非常相似，只有一個最主要的不同：tasks可以返回一個值。因此，你可以暫存這個返回值來作為這個線程的更抽象的定義方式，並在你真的需要返回的結果的時候來從這個返回值中拿到數據。

下面就是使用Tasks的例子：

#include <future>
//Tasks, Future, and Promises
    {
        auto f1 = [](std::vector<int> &v, 
            unsigned int left, unsigned int right) {
            unsigned long long acm = 0;
            for (unsigned int i = left; i < right; ++i)
            {
                acm += v[i];
            }

            return acm;
        };

        auto t1 = std::async(f1, std::ref(v), 
            0, v.size() / 2);
        auto t2 = std::async(f1, std::ref(v), 
            v.size() / 2, v.size());

        //You can do other things here!
        unsigned long long acm1 = t1.get();
        unsigned long long acm2 = t2.get();

        std::cout << "acm1: " << acm1 << endl;
        std::cout << "acm2: " << acm2 << endl;
        std::cout << "acm1 + acm2: " << acm1 + acm2 << endl;
    }

上面這段你需要知道：

　　1.tasks使用std::async創建

　　2.std::async的返回值是一個叫std::future的類型。別被他的名字唬到，他的意思是t1和t2的值會在未來被真正的賦值。我們通過調用t1.get()來獲得他的真正的返回值。

　　3.如果future的返回值還沒有准備好（任務還沒有計算完成），那么調用get()的主線程會被卡住，直到准備好了返回值（和join()的行為一樣）。

　　4.注意，我們傳遞給std::async的函數（實際上是lambda表達式）是有返回值的，這個返回值用過一個叫做std::promise的類型來傳遞。大多數情況下你不需要了解任何promise的細節，C++在幕后可以處理好這些事情。

　　5.默認的情況下，tasks也會在創建之后立刻運行（有辦法來修改這個行為，但是本文沒有涉及）。

線程創建的總結：

　　創建線程很簡單，你可以通過函數指針、偽函數、lambda表達式的方式來創建std::thread，也可以使用std::async的方式來獲得一個std::future類型的返回值。std::async也同樣可以使用函數指針、偽函數、lambda表達式來創建

（未完待續）