c++并发编程实战-第2章 线程管控

线程的基本管控

每个应用程序都至少拥有一个线程，即运行main函数的线程，称为主线程，它由c++运行时系统启动。我们可以在软件运行中产生其他线程，它们以指定的函数作为入口函数。当main函数返回后，程序会退出；同样，当入口函数返回后，与之对应的线程结束。

发起线程

线程是通过构造std::thread对象启动，该对象指明要运行的任务。任务可以是一个普通的函数，也可以是一个可调用对象。只要是通过C++标准库启动线程，归根到底，代码总会构造一个std::thread对象。std::thread构造函数定义如下：

explicit thread(_Fn&& _Fx, _Args&&... _Ax);

//_Fx：可调用对象
//_Ax：传递给可调用对象的参数包

下面列举出构建线程的几种方法：

方法一：普通函数

void do_some_work(int nVal);

int a = 10;
std::thread my_thread(do_some_work, a);

方法二：可调用对象

class someWork
{
public:
    void operator()()const 
    {
        do_some_work();
    }
};

someWork sw;
std::thread my_thread(sw);

在使用函数对象构造线程时，需要注意“C++最麻烦的解释”问题。即在构造std::thread对象时，传递临时对象，而不是具名变量，那么调用构造函数的语法可能与函数声明相同，产生二义性。例如：

std::thread my_thread(someWork());

本意是想构造一个线程对象，却被解释为函数声明，返回值类型为std::thread，函数名为my_thread，函数参数是一个函数指针，该函数指针没有参数和函数名，返回someWork类型对象，类似于：

void func(int(x), int())
{
    std::cout << x << " : " /*<< y */<< std::endl;
}

int test() { return 10; }

int main()
{
    func(10, test);
}

为了避免出现上述情况，可以用初始化列表或者多加一对括号：

std::thread my_thread{someWork()};    //初始化列表
std::thread my_thread((someWork()));  //多加一对括号

方法三：lambda表达式

auto cbk = [](){ do_some_work(); };
std::thread my_thread(cbk);

方法四：类对象的成员函数作为入口函数 

class ThreadEntry
{
public:
    void Process_some_data(int x) 
    {
        cout << "thread_id : " << this_thread::get_id() << endl;
    }
};

int main()
{
    cout << "main thread id : " << this_thread::get_id() << endl;
    ThreadEntry entry;
    std::thread th(&ThreadEntry::Process_some_data, &entry, 20);
    th.join();
}

等待与分离

一旦std::thread对象被构建后，线程就可能会被执行，因此，我们需要明确指定是等待该线程结束，或是任由它独自运行。假设等到std::thread对象销毁时还未决定好，那么std::thread对象的析构函数将调用std::terminate函数终止整个程序。因此，创建线程后，必须调用如下函数中的一个：

th.join();　　　　　　//等待
th.detach();　　　　　//分离

等待

若需等待线程完成，那么可以在与之关联的std::thread实例上，通过调用成员函数join()实现。该函数会阻塞当前线程，并等待线程示例结束后join()函数才返回。

void do_some_work()
{
    std::cout << "do_some_work start" << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(3));
    std::cout << "do_some_work end" << std::endl;
}

int main()
{
    std::thread th(do_some_work);
    std::cout << "main start" << std::endl;
    th.join();    //会等待子线程入口函数返回后该函数才返回
    std::cout << "main end" << std::endl;
}

输出：

main start
do_some_work start
do_some_work end
main end

如果子线程中处理的数据量特别大，那么join()函数可能等到天荒地老。也有可能在调用join()函数时，该线程已经结束，那么join()将立即返回。如果只想等待特定事件，可以通过条件变量或者future完成，会在后续章节中介绍。join()函数只能调用一次；只要线程对象曾经调用过join()函数，该线程就不可再汇合，可以通过joinable()成员函数判断当前线程是否可汇合，当线程已经调用过join()函数，那么joinable()函数将返回false。

如果选择等待线程结束，则需要选择合适的位置来调用join()函数。最重要一个原因是线程启动后有异常抛出，而join()尚未执行，则该join()调用会被略过，从而导致应用程序终止。可以运用RAII手法，构造一个thread_guard类，在析构函数中调用join()。代码如下：

class thread_guard
{
public:
    explicit thread_guard(std::thread& th) : m_th(th) {}
    ~thread_guard() 
    {
        if (m_th.joinable())  //避免多次调用join
            m_th.join();
    }
    thread_guard(const thread_guard&) = delete;
    thread_guard& operator=(const thread_guard&) = delete;

private:
    std::thread& m_th;
};

用法如下：

void threadEntry(int* pData)
{
    ...
}

void func()
{
    int nLocalData = 0;
    std::thread th(threadEntry(&nLocalData));
    thread_guard(th);
    do_something_in_current_thread();    //该函数可能导致异常
}

即使在do_something_in_current_thread()函数中发生了异常行为，线程对象同样也能正确调用join函数汇合。

分离

若不需要等待线程结束，可以调用detach成员函数将线程分离，从而避免异常引发的安全问题。分离操作会切断线程和std::thread对象间的关联，后续无法通过std::thread对象再操作该线程。被分离后的线程会在后台运行，由c++运行时库托管，当该线程运行完毕，与之对应的资源将被回收。

如果要把std::thread对象和线程分离，就必须存在与其关联的执行线程。若没有与其关联的执行线程，便不能在std::thread对象上凭空调用detach()。可以用joinable()函数检测。仅当joinable()函数返回true时，才能调用detach函数。

以下做法极不可取：意图在函数中创建线程，并让线程访问函数的局部变量。除非线程肯定会在该函数退出前结束，否则切勿这么做。代码如下：

class ThreadOperator
{
public:
    ThreadOperator(int& nData) : m_nData(nData) {}
    void operator()()
    {
        do_some_work(m_nData);  //对象的引用，可能该对象已经被销毁
    }
private:
    int& m_nData;
};

void func()
{
    int nLocalData = 0;
    ThreadOperator op(nLocalData);
    std::thread  th(op);
    th.detach();                //不等待线程结束
}

可能func函数已经结束，而线程还在运行，此时访问nLocalData将会出现崩溃。 上述情形的处理方法通常是：令线程函数完全自含（self-contained），即将数据复制到新线程内部，而不是共享数据。

ThreadOperator(int nData) : m_nData(nData) {}

向线程函数传递参数

若需向新线程上的函数或可调用对象传递参数，方法相当简单，直接向std::thread的构造函数增添更多参数即可。

class someWork
{
public:
    void operator()(int x, double y)const
    {
        cout << x << " : " << y << endl;  // 10 : 23.5
    }
};

int main()
{
    std::thread th(someWork(), 10, 23.5);    //根据参数表依次传递
    th.join();
}

参数传递流程

std::thread对象拥有自己的内部存储空间，传递的参数首先会按照默认方式拷贝到std::thread对象内部，之后以右值形式移动给线程的入口函数，即一次拷贝，一次移动。例如：

class Res_Data
{
public:
    Res_Data()
    {
        cout<<"Constractor"<<endl;
    }

    ~Res_Data()
    {
        cout<<"Destractor"<<endl;
    }

    Res_Data(const Res_Data& )
    {
        cout<<"Copy Constractor"<<endl;
    }

    Res_Data& operator=(const Res_Data&)
    {
        cout<<"Copy Assignment Operator"<<endl;
        return *this;
    }

    Res_Data(Res_Data&& )
    {
        cout<<"Move Constractor"<<endl;
    }

    Res_Data& operator=(Res_Data&&)
    {
        cout<<"Move Assignment Operator"<<endl;
        return *this;
    }
};

void func(Res_Data data) { }

int main()
{
    Res_Data data;
    thread th(func, data);
    th.join();
    cout<<"Main End"<<endl;
    return 0;
}

输出：

Constractor
Copy Constractor
Move Constractor
Destractor
Destractor
Main End
Destractor

注：上面代码在不同的编译器、相同编译器的不同版本可能存在差异，如有需要，请查询c++返回值优化（RVO机制）。本例是在Qt Creator 6.2.4 msvc2019 64位上测试得出。

将func()函数的参数换成引用类型：

void func(const Res_Data& data) { }

输出：

Constractor
Copy Constractor      //依旧发生了一次拷贝构造
Destractor
Main End
Destractor

我们发现，在传递参数时，即使入口函数是使用的“万能引用（const reference）”，依旧会发生一次拷贝构造，这一点非常重要。如果想避免此次拷贝，可以在构造线程对象时，用ref函数包裹对象，例如：

thread th(func, std::ref(data));

输出：

Constractor
Main End
Destractor

如果代码使用的detach()函数汇合，再次强调，不要向线程的入口函数传递局部变量的引用或者指针！

注意点1

上面的func函数中，使用的是万能引用，实际上还可以用移动语义，但切记不要使用普通引用：

void func(const Res_Data& data) { }    //万能引用
void func(Res_Data&& data) { }         //移动语义
void func(Res_Data& data) { }          //error

原因是：std::thread对象在传递参数给入口函数时，使用的是右值。而普通引用只能引用左值。

注意点2

如果传递的是指针，使用detach同样会出现访问局部变量的问题，例如：

void func(char* pData)
{
    cout << pData << endl;               //pData : 0x00effdac
}

int main()
{
    char pBuf[] = "abcdef";             //pBuf : 0x00effdac
    thread th(func, pBuf);
    th.detach();
}

我们发现，pData 与 pBuf地址相同，此时同样会出现异常。接下来我们来改进上面代码，将func()入口函数中的char*改为string类型，通过string的构造函数将char*隐式转换为string类型。代码如下：

void func(string sData)
{
    cout << sData<< endl;
}

int main()
{
    char pBuf[] = "abcdef";
    thread th(func, pBuf);      //pBuf会调用string的构造函数构造string对象
    th.detach();
}

上面代码实际上是存在缺陷的，在工作中我们很容易遇到类似的问题。前面说过，std::thread对象存在自己的内部存储空间，将pBuf传递给std::thread对象时，会直接等位拷贝一份pBuf，此时这两个指针都指向同一份内存。假设此时main函数执行结束，子线程还未运行，后续当子线程运行时，通过拷贝的指针去构建对象，此时内存已经被回收，产生异常。那到底应该如何解决这个问题呢？

int main()
{
    char pBuf[] = "abcdef";
    thread th(func, string(pBuf));//pBuf会调用string的构造函数构造string对象
    th.detach();
}

只需要手动构建string对象即可。切记：在向线程传递对象时，不要使用对象的隐式类型转换。

注意点3

当一个类对象仅支持移动语义时，需要手动调用std::move来转移对象的归属权。比如，如果需要向线程入口函数传递一个std::unique_ptr对象，该对象只支持移动，而不支持拷贝。例子如下：

class big_obj
{
public:
    big_obj() {}
    void setdata(int nData) { m_nData = nData; }

    void print() 
    {
        cout << m_nData << endl;
    }

private:
    int m_nData = 0;
};

void process_big_object(std::unique_ptr<big_obj> _ptr)
{
    cout << "son thread : " << this_thread::get_id() << endl;
    _ptr->print();
}

int main()
{
    cout << "main thread : " << this_thread::get_id() << endl;
    std::unique_ptr<big_obj> pObj = std::make_unique<big_obj>();  //构造std::unique_ptr对象
    pObj->setdata(10);
    std::thread th(process_big_object, std::move(pObj));  //将std::unique_ptr对象传递给线程入口函数
    th.join();
}

移交线程归属权

std::thread对象仅支持移动语义，而不支持对象拷贝。对于一个具体的执行线程，其归属权可以在不同的作用域间转换，例如：

void do_some_work() {}
void do_work(){}

std::thread th1(do_some_work);
std::thread th2(std::move(th1));
std::thread th3;
th3 = std::move(th2);

std::thread th4(do_work);
th4 = std::move(th3);      //error

切记：当一个std::thread对象正在管控一个线程，就不能将新的线程交由其管控，否则将会导致程序崩溃。

移动语义允许函数向外部转移线程的归属权，同时也允许将线程的归属权转移至某个函数内，示例如下：

void do_work(){}

std::thread GetThread()
{
    std::thread th(do_work);
    return th;    //将该线程交由外部管理
}

void ProcessThread(std::thread th)    //交由某个函数管理
{
    if(th.joinable())
        th.join();
}

因为std::thread支持移动语义，所以只要容器同样知悉移动意图，就可以将std::thread作为元素存入容器中。因此，我们可以产生多个线程对象，将其保存在容器中，集中管理。

void func()
{
    std::vector<std::thread> vThreads;
    for (int i = 0; i < 10; ++i)
    {
        vThreads.emplace_back(do_work, i);
    }

    for (auto& itr : vThreads)
        itr.join();
}

在运行时选择线程数量

 

可以使用标准库提供的std::thread::hardware_concurrency()函数，该函数用于获取软件运行时可用于并发的线程数量。例如在多核系统上，该值可能是CPU的核芯数量。若线程信息无法获取，该值可能返回0。若需要使用多线程分解完整的任务，该值不失为一个有用的指标。

例如，下面例子用于实现一个多线程版本的accumulate累加函数：

template<typename Iterator, typename T>
struct accumulate_block
{
    void operator()(Iterator first, Iterator last, T& result)
    {
        result = std::accumulate(first, last, 0);
    }
};

template<typename Iterator, typename T>
T parallel_accumulate(Iterator first, Iterator last, T init)
{
    unsigned long const length = std::distance(first, last);
    if (!length)
        return init;

    unsigned long const min_per_thread = 25;
    unsigned long const max_thread = (length + min_per_thread - 1) / min_per_thread;
    unsigned long const hardware_threads = std::thread::hardware_concurrency();
    unsigned long const num_thread = std::min(hardware_threads != 0 ? hardware_threads : 2, max_thread);

    unsigned long const block_size = length / num_thread;

    std::vector<T>results(num_thread);
    std::vector<std::thread> ths(num_thread - 1);
    Iterator block_start = first;

    for (int i = 0; i < num_thread - 1; ++i)
    {
        Iterator block_end = block_start;
        std::advance(block_end, block_size);

        accumulate_block<Iterator, T> _block;
        std::thread th = std::thread(_block, block_start, block_end, std::ref(results[i]));
        ths[i] = std::move(th);
        block_start = block_end;
    }
    accumulate_block<Iterator, T>()(block_start, last, std::ref(results[num_thread - 1]));

    for (auto& itr : ths)
        itr.join();

    return std::accumulate(results.begin(), results.end(), init);
}

识别线程

每个线程都有标识自己的唯一ID，类型为std::thread::id。可以通过std::thread类对象成员get_id()函数获取该线程的线程ID，也可以通过std::this_thread::get_id()函数获取。这两个函数的区别在于，前者需要获取std::thread对象，由该对象调用成员函数，而后者则是全局函数，可以在任意位置调用，该函数返回当前线程的线程ID。

std::thread::id类型作为标识线程ID的类，可以随意进行复制操作或比较运算。如果两个ID对象相等，则表示他们是同一个线程，或者表示这两个线程都不存在。std::thread::id类型可以用作关联容器的键值。

Copyright

本文参考至《c++并发编程实战》 第二版，作者：安东尼·威廉姆斯。本人阅读后添加了自己的理解并整理，方便后续查找，可能存在错误，欢迎大家指正，感谢！