在以前，要想在C++程式中使用執行緒，需要呼叫作業系統提供的執行緒庫，比如linux下的<pthread.h>。但畢竟是底層的C函式庫，沒有什麼抽象封裝可言，僅僅透露著一種簡單，暴力美

C++11在語言級別上提供了執行緒的支援，不考慮效能的情況下可以完全代替作業系統的執行緒庫，而且使用起來非常方便，為開發程式提供了很大的便利

Linux下的原生執行緒庫

pthread庫函式

建立執行緒採用pthread_create函式，函式宣告如下

#include <pthread.h>
/* 
 * pid : 執行緒id，傳入pthread_t型別的指標，函式返回時會返回執行緒id
 * attr : 執行緒屬性
 * func : 執行緒呼叫的函式
 * arg : 給函式傳入的引數
 */
 

int pthread_create(pthread_t* pid, const pthread_attr_t* attr, void*(*func)(void*), void* arg);

可以發現，建立執行緒時只能傳遞一個引數給執行緒函式，所以如果想要給函式傳入多個引數的話就需要動點歪腦筋，比如如果是類物件的話可以傳入this指標，或者也可以將引數封裝成一個struct傳進去。不過總感覺不太優雅

當一個程序建立一個執行緒時，雖然執行緒執行在主程序的記憶體空間中，但是每個執行緒也有自己的私有空間(資源，如區域性變數等)。當程式正常退出時，執行者是希望執行緒的私有資源可以成功被作業系統回收(即資源回收)，這就需要主程序在退出之前顯示呼叫pthread_join函式，該函式會等待引數id代表的執行緒退出，然後回收其資源，如果呼叫時目標執行緒還沒有執行結束，那麼呼叫方(主程序)會被阻塞

當然，如果覺得這樣太麻煩，也可以使用pthread_detach函式主動分離執行緒，這樣，當執行緒執行結束後會由作業系統自動回收資源，不再需要主程序操心

還有一個常用的api是pthread_exit，用於主動結束當前執行緒

示例：若干執行緒併發對一個數進行自增操作

使用示例，建立10個執行緒對程序全域性變數n做加法，每個執行緒加10000次

#include <unistd.h>
#include <pthread.h>
#include <sys/types.h>

#include <iostream>

long long int
 
 n = 0;
void *thread_func(void* arg)
{
    for(int i = 0; i < 10000; ++i)
        ++n;
    ::pthread_exit(nullptr);
}

int main()
{
    for(int i = 0; i < 10; ++i)
    {
        pthread_t pid;
        ::pthread_create(&pid, nullptr, thread_func, nullptr); 
        ::pthread_detach(pid);
    }
    ::sleep(1); //等待所有執行緒正常退出
    std::cout << n << std::endl;
    return 0;
}

當然最後這個結果絕不可能是100000，要想保證正確性，需要互斥鎖協助。

C++11執行緒庫

簡單介紹了posix原生執行緒的使用，一方面用於複習，另一方面自然是為了引出主角。C++11引入執行緒庫std::thread，使得C++在語言級別上支援執行緒，雖然大家都說效能不咋地，但是用起來自然是方便許多。突出的幾個特點有

• 支援lambda，建立執行緒可以傳入lambda作為執行函式，太方便了有木有~
• 支援任意多個引數，由於C++模板支援可變引數列表，所以實現多引數傳遞還是蠻容易的
• 使用方便，各種函式都經過了良好設計，使用起來比posix不知道高到哪裡去了

小插曲，介紹了這麼多好處當然也要吐槽一下，編譯C++11執行緒庫居然要手動連結-lpthread庫….

建立執行緒的幾種方式

使用執行緒庫需要引入標頭檔案<thread>，有下面幾種方法建立執行緒

#include <iostream>
#include <thread>
#include <chrono>
#include <functional>


class ThreadTask
{
public:
    ThreadTask(int a, int b)
        : a_(a), b_(b)
    {  }

    void operator()()
    {
        std::cout << "hello " << std::this_thread::get_id() << std::endl;
        std::cout << "a + b = " << a_ + b_ << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << "world " << std::this_thread::get_id() << std::endl;
    }

private:
    int a_;
    int b_;
};

void func(int a)
{
    std::cout << "hello " << std::this_thread::get_id() << std::endl;
    std::cout << a << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "world " << std::this_thread::get_id() << std::endl;
}

int main()
{
    std::thread t1(func, 1);    //接收一個函式指標和引數列表
    std::thread t2([]() {
        std::cout << "hello " << std::this_thread::get_id() << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << "world " << std::this_thread::get_id() << std::endl;
    });                         //接收lambda
    ThreadTask task(1, 2); 
    std::thread t3(task);       //接收函式物件

    t1.join(); //t1.detach();
    t2.join(); //t2.detach();
    t3.join(); //t3.detach();
               //std::this_thread::sleep_for(std::chrono::seconds(1));
    return 0;
}

需要注意的是，std::thread物件是不允許拷貝的，拷貝建構函式和拷貝賦值運算子被指定為delete

執行緒的移動語義

雖然不允許拷貝，但是std::thread是允許移動的

int main()
{
    std::thread t1([]() {
        std::cout << "hello " << std::this_thread::get_id() << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << "world " << std::this_thread::get_id() << std::endl;
    });
    std::thread t2(std::move(t4));  //移動建構函式
    std::thread t3;
    t3 = std::move(t2); //移動賦值運算子

    t3.join();
    return 0;
}

示例：利用std::thread實現並行的accumulate函式

標準庫std::accumulate函式用於對給定區間的元素依次運算，預設是加法，使用示例

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

int main()
{
    vector<int> v{1, 3, 5, 7, 9, 12};
    /* 輸出37,即所有元素的和 */
    std::cout << std::accumulate(v.begin(), v.end(), 0) << std::endl;
    /* 輸出5，即所有元素異或的結果 */
    std::cout << std::accumulate(v.begin(), v.end(), 0, bit_xor<int>()) << std::endl;
    return 0;
}

下面利用std::thread實現並行accumulate，即利用多執行緒的優勢同時計算不同區塊

首先是根據給定區間計算建立的執行緒個數，std::thread標準庫中提供了hardware_concurrency()函式，該函式返回當前計算機支援的併發執行緒數，通常是cpu核數，如果值無法計算則返回0。

在此之前，最好規定每個執行緒最小計算的元素個數，不然如果建立執行緒過多，導致每個執行緒計算的元素個數很少，那麼建立執行緒帶來的開銷就會大於運算開銷，得不償失。所以可以規定每個執行緒最少計算20個元素

template <class Distance>
auto getThreadNums(Distance count)
{
    auto avaThreadNums = std::thread::hardware_concurrency();
    auto minCalNums = 20;
    /* 將count向上取整到20的整數倍，計算最大需要多少個執行緒 */
    auto maxThreadNums = ((count + (minCalNums - 1)) & (~(minCalNums - 1))) / minCalNums;
    /* 選擇二者中最合適的那個 */
    return avaThreadNums == 0 ? maxThreadNums : std::min(static_cast<int>(avaThreadNums), static_cast<int>(maxThreadNums));
}

通過執行緒個數，就可以計算每個小區間負責的元素個數，從而將區間[front, last)拆分成若干個小區間

auto count = std::distance(first, last);
int threadNums = getThreadNums(count);
int blockSize = count / threadNums; //區間大小

接下來的工作就是建立threadNums個執行緒，每個執行緒呼叫std::accumulate計算自己負責的區間結果，同時將結果儲存，最後將每個區間的結果再求一次std::accumulate

template <class InputIt, class T>
T parallel_accumulate(InputIt first, InputIt last, T init)
{
    auto count = std::distance(first, last);
    int threadNums = getThreadNums(count);
    int blockSize = count / threadNums;
    std::vector<std::thread> threads;
    std::vector<T> results(threadNums);
    auto front = first;
    for(int i = 0; i < threadNums; ++i)
    {
        auto back = front;
        if(i != threadNums - 1)
            std::advance(back, blockSize);
        else
            back = last;
        threads.emplace_back([front, back, &results, i, init] { results[i] = std::accumulate(front, back, init); });
        front = back;
    }
    for(auto& th : threads)
        th.join();
    return std::accumulate(results.begin(), results.end(), init);
}

測試程式碼為

#include <iostream>
#include <algorithm>
#include <vector>
#include <thread>
#include <future>
#include <chrono>
#include <functional>
#include <random>

#include "../../tinySTL/Profiler/profiler.h"


/* parallel_accumulate的實現 */
...

int main()
{
    std::vector<long long int> v(100000000);
    std::random_device rd;
    std::generate(v.begin(), v.end(), [&rd]() { return rd() % 1000; });
    tinystl::Profiler::ProfilerInstance::start(); 
    auto result = parallel_accumulate(v.begin(), v.end(), 0);
    tinystl::Profiler::ProfilerInstance::finish(); 
    tinystl::Profiler::ProfilerInstance::dumpDuringTime(); 
    std::cout << result << std::endl;

    tinystl::Profiler::ProfilerInstance::start(); 
    result =  std::accumulate(v.begin(), v.end(), 0);
    tinystl::Profiler::ProfilerInstance::finish(); 
    tinystl::Profiler::ProfilerInstance::dumpDuringTime(); 
    std::cout << result << std::endl;
    return 0;
}

輸出結果

g++ thread.cpp -o thread -std=c++14 -lpthread -g    //編譯
./thread    //執行
total 213.717 milliseconds
-1584776879
total 776.649 milliseconds
-1584776879

雖然都溢位了，但是可以看出平行計算快很多

小結

C++11提供的執行緒庫使用起來比較方便，以前在學習多執行緒程式設計時一直使用的posix原生執行緒庫，剛剛接觸C++11時感覺方便很多，後面會繼續學習互斥鎖，條件變數的使用。