c++11 Thread库写多线程程序

一个简单的使用线程的Demo

       c++11提供了一个新的头文件<thread>提供了对线程函数的支持的声明(其他数据保护相关的声明放在其他的头文件中，暂时先从thread头文件入手吧)，写一个多线程的程序需要引用这个新的头文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
#include <thread>
 
void fun()
{
   std::cout << "A new thread!" << std::endl;
}
 
int main()
{
    std::thread t(fun);
    t.join();
    std::cout << "Main thread!" << std::endl;
}

　　这样的demo就是一个简单的多线程的应用了。其输出如下：

1
2
A new thread!
Main thread!

因此我们可以猜测到它的执行流大致是这样的：

那么程序的执行流是如何从main()转去执行fun()的呢，下面我们先看看thread这个类。

线程的启动

      我的环境是CentOS7 + g++4.8.3 头文件/usr/include/c++/4.8.3/thread中有thread类的完整声明（我的windows环境是win8.1+vs2013，在默认安装的情况下thread头文件的路径是C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\include\thread）。代码太长，我就不贴出来了。c++线程库通过构造一个线程对象，来启动一个线程。那么我们就先来看一下thread的构造函数：

以下贴出thread类的代码均是出自GNU的实现版本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class thread
{
    ...
public:
    thread() noexcept = default;
    thread(thread&) = delete;
    thread(const thread&) = delete;
    thread(thread&& __t) noexcept
    { swap(__t); }
    template<typename _Callable, typename... _Args>
    explicit thread(_Callable&& __f, _Args&&... __args)
    {
        _M_start_thread(_M_make_routine(std::__bind_simple(
        std::forward<_Callable>(__f),
        std::forward<_Args>(__args)...)));
     }
    ...
};

这几行代码里边，却有着大量的有关c++11特性的内容，右值引用、noexcept、=delete、以及可调用对象这些不是本篇博客要关注的点，因此就不详细的展开了。我们主要来看这个构造函数模板，

template<typename _Callable, typename... _Args>
explicit thread(_Callable&& __f, _Args&&... __args);

可以清楚的看见它把参数都交给了std::__bind_simple()处理了，而对于std::__bind_simple()的定义在其头文件<functional>中，和std::bind()的用法一样，具体区别建议还是看看头文件比较好，这里我就多个事，顺手就贴出来了：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
template<typename _Callable, typename... _Args>
typename _Bind_simple_helper<_Callable, _Args...>::__type
__bind_simple(_Callable&& __callable, _Args&&... __args)
{
    typedef _Bind_simple_helper<_Callable, _Args...> __helper_type;
    typedef typename __helper_type::__maybe_type __maybe_type;
    typedef typename __helper_type::__type __result_type;
    return __result_type(
        __maybe_type::__do_wrap( std::forward<_Callable>(__callable)),
        std::forward<_Args>(__args)...);
}
    
template<typename _Result, typename _Func, typename... _BoundArgs>
inline typename _Bindres_helper<_Result, _Func, _BoundArgs...>::type
bind(_Func&& __f, _BoundArgs&&... __args)
{
    typedef _Bindres_helper<_Result, _Func, _BoundArgs...> __helper_type;
    typedef typename __helper_type::__maybe_type __maybe_type;
    typedef typename __helper_type::type __result_type;
    return __result_type(__maybe_type::__do_wrap(std::forward<_Func>(__f)),
       std::forward<_BoundArgs>(__args)...);
}

功力有限std::bind()具体实现我就不深究了，有机会我在研究研究。但是不难看出，这两个函数的作用大体上就是封装一个函数及其参数，返回一个__type类。thread在构造一个新的对象时，便是传入了一个__type对象给_M_start_thread()实现启动一个线程的。为什么要这样做呢？我们可以认为这是由于OS的实现（我也是网上听说，如果你知道答案，不妨告诉我），用过Linux上的线程库pthread的应该对pthread_create()中的start_routine参数有印象，它是一个函数指针，其对应的函数原型如下：

void* (*start_routine) (void*);

这样就缩小了两者之间的差异，剩下的事就只要把__type的地址传进去就可以了。由于使用的这样的实现，std::thread()创建一个新的线程可以接受任意的可调用对象类型（带参数或者不带参数），包括lambda表达式（带变量捕获或者不带），函数，函数对象，以及函数指针。

      上面我们写了一个不带参数的demo，现在我们就创建包含参数和捕获的lambda表达式看看是否真的是这样，demo：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <thread>
#include <iostream>
 
int main()
{
    int n1 = 500;
    int n2 = 600;
    std::thread t([&](int addNum){
        n1 += addNum;
        n2 += addNum;
    },500);
    t.join();
    std::cout << n1 << ' ' << n2 << std::endl;
}

得到了预期结果：

1
2
[thread]main
1000 1100
线程结束

      在启动了一个线程（创建了一个thread对象）之后，当这个线程结束的时候（std::terminate()），我们如何去回收线程所使用的资源呢？thread库给我们两种选择：1.加入式（join()） 2.分离式（detach()）。值得一提的是，你必须在thread对象销毁之前做出选择，这是因为线程可能在你加入或分离线程之前，就已经结束了，之后如果再去分离它，线程可能会在thread对象销毁之后继续运行下去。

Note that you only have to make this decision before the std::thread object is destroyed—the thread itself may well have finished long before you join with it or detach it, and if you detach it,then the thread may continue running long after the std::thread object is destroyed.-------《C++ Concurrency In Action》 2.1.1

      join()字面意思是连接一个线程，意味着主动地等待线程的终止，上面的例子我都是使用了join()的方式。join()是这样工作的，在调用进程中join(),当新的线程终止时，join()会清理相关的资源（any storage associated with the thread）,然后返回，调用线程再继续向下执行。正是由于join()清理了线程的相关资源，因而我们之前的thread对象与已销毁的线程就没有关系了，这意味着一个线程的对象每次你只能使用一次join()，当你调用的join()之后joinable()就将返回false了。光靠文字还是略显苍白的，肯定还是代码更加直观：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>
#include <thread>
 
void foo()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}
  
int main()
{
    std::thread t(foo);
    std::cout << "before joining,joinable=" << std::boolalpha << t.joinable() << std::endl;
    t.join();
    std::cout << "after joining, joinable=" << std::boolalpha << t.joinable() << '\n';
}

运行结果：

1
2
3
[thread]main
before joining,joinable=true
after joining, joinable=false

      第二种方式是分离式,对应的函数是detach()。detach这个词的意思是分离的意思，对一个thread对象使用detach()意味着从调用线程分理出这个新的线程，我们称分离的线程叫做守护线程（daemon threads）。之后也就不能再与这个线程交互。打个不太恰当的比方，就像是你和你女朋友分手（你可能说我好坏，为什么不说是我和我的女朋友？因为我没有女朋友啊，哈哈，看我多机智。），那之后你们就不会再有联系（交互）了，而她的之后消费的各种资源也就不需要你去埋单了（清理资源）。既然没有交互，也就谈不上join()了，因此调用joinable()必然是返回false。分离的线程会在后台运行，其所有权(ownership)和控制权将会交给c++运行库。同时，C++运行库保证，当线程退出时，其相关资源的能够正确的回收。

      分离的线程，大致上是这样执行的，它运行结束后，不再需要通知调用它的线程：

线程的标识符

      在thread类中有一个叫做_M_id的私有变量用来标识线程，其类型是std::thread::id,在GNU上实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class thread
{
    ...
    class id
    {
      native_handle_type    _M_thread;
    public:
      id() noexcept : _M_thread() { }
      explicit
      id(native_handle_type __id) : _M_thread(__id) { }
    private:
      friend class thread;
      friend class hash<thread::id>;
      friend bool
      operator==(thread::id __x, thread::id __y) noexcept
      { return __gthread_equal(__x._M_thread, __y._M_thread); }
      friend bool
      operator<(thread::id __x, thread::id __y) noexcept
      { return __x._M_thread < __y._M_thread; }
      <br>      template<class _CharT, class _Traits>
      friend basic_ostream<_CharT, _Traits>&
      operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id);
    };
 
private:
    id              _M_id;
public:
    thread::id
    get_id() const noexcept
    {
        return _M_id;
    }
    ...
};

      代码还是比较清晰的，很明显我们可以通过std::this_thread::get_id()这个函数获取线程的标识符，由于上面的代码中thread::id类中重载了operator “<<”运算符，因此我们可以对id类型进行输出。同时，当一个thread对象并没有关联一个线程的时候（可能thread对象是默认初始化的或者初始化的线程已经运行结束被join()或者是线程已经detach()），这时候get_id()将返回默认构造的id对象，意味着这个thread对象不存在关联的线程，输出可能像是这样的：“thread::id of a non-executing thread”。与此同时，我们也可以在当前的线程中获取当前线程的线程标识符，方法比较简单直接调用std::this_thread::get_id()即可。

      现在，我们写一个使用标准输出尝试输出线程id的demo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>
#include <thread>
 
void fun()
{
    std::cout << std::this_thread::get_id() << std::endl;
}
 
int main()
{
    std::thread t(fun);
    std::cout << t.get_id() << std::endl;
    t.join();
}

　　其输出结果是一个15位的整数，具体取决于实现，当然具体怎么实现并无区别，我们只要关心它可以作为标识线程的一种手段：

1
2
3
[thread]main
140302328772352
140302328772352

      同时，std::thread::id中还重载了operator==,这样就允许我们去比较两个线程是否相等（是否是同一个线程），比如我们需要给不同的线程分配任务或者限制某个线程的操作，id类型实现了这样的比较运算给了我们编程时极大的便利。

posted @ 2019-09-10 21:43  会飞的斧头  阅读(3209)  评论(0)  编辑  收藏  举报