c++11 Thread库初探

c++11中最重要的特性之一就是对多线程的支持了,然而《c++ primer》5th却没有这部分内容的介绍,着实人有点遗憾。在网上了解到了一些关于thread库的内容。这是几个比较不错的学习thread库的资源:

Thread support library                    : http://en.cppreference.com/w/cpp/thread

Cpp reference/thread                      : http://www.cplusplus.com/reference/thread/

<< C++ Concurrency In Action >>  :http://files.cnblogs.com/files/ittinybird/CplusplusConcurrencyInAction.pdf             //Recommend!

前两个网站我还是非常喜欢的,都是在线的帮助手册,两个选择其中一个就可以了,看你口味选择就好了。最后一个是原版的《C++ Concurrency In Action》,非常棒的一本书,鉴于中文译版已经被黑出翔了,所以能看英文就看英文版吧,我也是硬着头皮啃了一点儿。以下是我学习thread库的一点感受和见解,如果你有发现我的错误,还请你及时批评指正,我将万分感谢

有关线程、并发相关的基础知识,我就不浪费篇幅了。

一个简单的使用线程的Demo

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

#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就是一个简单的多线程的应用了。其输出如下:

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的实现版本

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()的用法一样,具体区别建议还是看看头文件比较好,这里我就多个事,顺手就贴出来了:

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:

#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;
}

得到了预期结果:

[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了。光靠文字还是略显苍白的,肯定还是代码更加直观:

#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‘;
}

运行结果:

[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上实现如下:

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; }
            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:

#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位的整数,具体取决于实现,当然具体怎么实现并无区别,我们只要关心它可以作为标识线程的一种手段:

[thread]main
140302328772352
140302328772352

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

      关于何时用到std::thread::id::operator<,我暂时没有搞清楚,如果您知道,不妨告诉我,我将万分感激。

      理解了以上内容,我们基本可以使用多线程去实现一些简单的任务了,当然要想安全地使用线程,这还是远远不够的。接下来我还要再探、三探thread库。

如若以上博文有错误、误导之处,请你原谅,还望批评指正,我在此先谢过各位。

时间: 2024-11-05 18:59:29

c++11 Thread库初探的相关文章

再探c++11 Thread库之原子操作

我在之前一篇博文<初探c++11 Thread库之使写多线程程序>中,着重介绍了<thread>头文件中的std::thread类以及其上的一些基本操作,至此我们动手写多线程程序已经基本没有问题了.但是,单线程的那些"坑"我们仍还不知道怎么去避免. 多线程存在的问题 多线程最主要的问题就是共享数据带来的问题.如果共享数据都是只读的,那么没问题,因为只读操作不会影响到数据,更不会涉及对数据的修改,所以所有线程都会获得同样的数据.但是,当一个或多个线程要修改共享数据

初探C++11 Thread

Thread 开启一个线程 使用c++11开启一个线程是比较简单的,如下: #include<iostream> #include<thread> using namespace std; void hello() { cout<<"hello kitty"<<endl; } int main() { std::thread t(hello); t.join(); return 0; } 输出结果: 也可以通过函数对象的方式 #inclu

C++11 正则表达式库 (regex)

Source: http://cpprocks.com/wp-content/uploads/c++11-regex-cheatsheet.pdf C++11 正则表达式库 (regex),布布扣,bubuko.com

Boost::thread库的使用

阅读对象 本文假设读者有几下Skills [1]在C++中至少使用过一种多线程开发库,有Mutex和Lock的概念. [2]熟悉C++开发,在开发工具中,能够编译.设置boost::thread库. 环境 [1]Visual Studio 2005/2008 with SP1 [2]boost1.39/1.40 概要 通过实例介绍boost thread的使用方式,本文主要由线程启动.Interruption机制.线程同步.等待线程退出.Thread Group几个部份组成. 正文 线程启动 线

BOOST之Thread库学习

//Boost并发编程之thread /*-----------------------------------------------------编译thread库 在工程中嵌入源码的方式: 直接在cpp文件中包含thread库的实现代码如下 #define BOOST_DATE_TIME_SOURCE #define BOOST_THREAD_NO_LIB #inclue<boost\thread.hpp> #ifdef _MSC_VER              //windows线程

使用C++11网络库Handy进行服务器端编程

Handy是一个简洁优雅的C++11网络库,适用于linux与Mac平台.十行代码即可完成一个完整的网络服务器. 下面是echo服务器的代码: #include <handy/handy.h> using namespace std; using namespace handy; int main(int argc, const char* argv[]) { EventBase bases; //事件分发器 Signal::signal(SIGINT, [&]{ bases.exit

使用c++11标准库转换字符编码

转自:http://www.cnblogs.com/LinuxHunter/archive/2013/01/06/2848293.html #include <stdio.h> #include <locale> #include <codecvt> const std::string ws2s( const std::wstring& src ) { std::locale sys_locale(""); const wchar_t* da

zlib1.2.11静态库使用

1.打开VS2013,为了测试的便捷,我们新建Win32控制台程序,且项目名称为zlibTest: 2.为了项目的直观,选中如图三个文件,右键移除,点击删除.你可以不必这么做,只是测试: 3.将已编译生成的zlib1.2.11静态库zlibstat.lib与头文件zconf.h / zlib.h(zlib1.2.11静态编译),一起放入新建的文件夹CommonFiles,移动到与工程同级目录(你可以放置到喜欢的地方): 4.VS2013解决方案,选择工程名zlibTest,右键属性,我们修改输出

c++11 thread (目前我使用的ZThread库)

目前为止(2014-11-30),GCC其实已经基本上完全支持C++11的所有功能了,事实上从GCC4.7之后,就支持了-std=c++11选项,在4.7版本之前,也开始支持-std=c++0x的选项了 但是目前由于MinGW工作组的问题(没有跟上GNU GCC工作组的步伐,事实上目前GCC已经更新到4.9了,MinGW-Installer中能获取的最新版本的G++还停留在4.8.1版本,不仅如此,尽管是4.8.1,MinGW并没有提供很多C++11应有的功能).(也就是说,你在非Windows