最近重新翻阅了一下c++11新特性，发现标准库中新增了线程类std::thread。实际试用之后，的确比原项目中使用POSIX标准的线程API封装程度更高，用起来也更简单。另外在c++11中还增加了atomic原子变量，简单类型的变量锁也被集成了。或许以后c++多线程开发都可以依赖于标准库进行了，可以省去例如多平台之类的兼容性考虑。

1. thread类构造

线程在thread变量定义时就已经创建并运行了（前提是通过绑定回调函数的方式定义），与之后的join或detach参数并无关系。

线程的启动入口即为构造函数中传递的函数和可变参数列表。函数可以使用全局函数/类静态成员函数，或是类成员函数，但类成员函数需要额外传递对应类的指针，否则编译会报错缺少对应参数。

而可变参数列表则对应着传递函数的参数，如果是类成员函数，那么第一个参数应该是对应类的对象或指针。

构造样例如下所示：

#include <thread>void func_global() {printf("callback func:%s\n", __func__);
}class WorkThread {
public:WorkThread() {}void func_memeber() { printf("callback func:%s\n", __func__); }static void func_static() { printf("callback func:%s\n", __func__); }
};int main() {std::thread thrd(func_global);					// 全局函数 std::thread thrd1(WorkThread::func_static);		// 类静态成员函数 WorkThread wthrd_tmp;std::thread thrd2(WorkThread::func_memeber, wthrd_tmp);	// 类成员函数// ...thrd.join();thrd1.join();thrd2.join();return 0;
}

2. thread类操作

与线程类相关的操作主要为join/detach/joinable/move四种，让我们来看看这些函数具体的作用。

join操作：如上图代码样例中所看到的，main函数末尾使用了thread类join函数。其作用为让当前线程等待对应线程工作，一直阻塞到线程工作完成后返回，join()才算执行完成。

detach操作：相比起join操作，detach是将对应线程"流放"，不再对其进行控制。需要注意的是，如果创建的子线程中使用了当前线程的变量内容，而当前线程又先于子线程销毁了，那就可能造成无效数据的访问。

joinable操作：该函数的主要作用如同其名字，就是检查线程是否可进行join/detach操作。只有未进行过join/detach操作的线程会返回true，其他则返回false。另外用默认构造函数创建的线程类返回也是false，因为其根本就没有创建过实际线程。

move操作：move函数其实并不是thread类的成员函数，其为c++11新增的右移操作函数。之所以在这里提到，是因为thread类不允许普通的拷贝构造，也不允许相互赋值。该唯一性保证了thread类是可控的，线程的所有权与管理者是明确的，也是线程类能够封装进标准库的前提。因此thread类只支持"转移"操作，我们可以利用move函数右值操作来转移对应的线程所有权。

关于move函数的详细内容大家可以搜索网上介绍，其中涉及了左值右值的概念，此处就暂且不做展开了。

3. thread类析构

只要是变量就会析构，thread类也不例外。但基于线程的特殊性，thread类为用户提供了两个选择：1.结束对应线程。2.分离对应线程。但无论是哪种，都需要用户自己提前决定。因此在thread类发生析构前，需要我们自己调用join或者detach进行处理。

若是不提前进行操作，标准库就会在析构时直接抛出异常，中断程序的运行。这点请务必注意。

4. 代码示例模型

基于thread类与atomic类，博主编写了一个简单的多进程模型。其中将线程创建/运行/销毁封装于WorkThead类内部，由其他类（如MainProcess）进行调用。该模型参考了博主以前项目中服务端进程处理消息的模式，通过多线程消费主进程提供的消息队列，进而提高CPU利用率。

运行后，输入"quit"退出。输入其他命令则会输出对应处理的线程名称。关于退出时调用join的方式可供大家参考，其保证了所有子线程退出后，主线程才会退出。

#include <stdio.h>
#include <thread>
#include <atomic>
#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <mutex>// 主进程 
class WorkThread;
class MainProcess {
public:friend class WorkThread;MainProcess(int thread_cnt);void Start();    // 启动进程，挂载对应数量的线程 void End();        // 结束进程,需要将其下各个线程退出bool GetPacket(std::string &packet);        // 线程安全取消息队列bool PushPacket(const std::string &packet); // 线程安全存消息队列 private:int thread_cnt_;std::atomic<int> value_;                // 使用c++11的原子性数据也可以 std::vector<WorkThread*> pthreads_;std::queue<std::string> packets_;        // 或者是自己维护加锁的数据结构 std::mutex lock_;
};// 工作线程(封装线程类)
class WorkThread {
public:WorkThread(MainProcess* mainpro, const std::string &thrd_name);void Start();void Run();void End();    // 线程结束时处理数据(如内存回收等) void StopRun();private:bool Dealcmd(const std::string &cmd);std::thread thd_;MainProcess *mainpro_;bool run_;std::string thread_name_;
};MainProcess::MainProcess(int thread_cnt) {thread_cnt_ = thread_cnt;value_ = 0;pthreads_.clear();
}void MainProcess::Start() {char szname[128];for (int i = 0; i < thread_cnt_; i++) {snprintf(szname, sizeof(szname), "thread_%d", i);WorkThread* pthread = new WorkThread(this, szname);pthreads_.push_back(pthread);}// 线程运行 for (auto &pthread : pthreads_) {pthread->Start();}// 若为服务端进程,此处应为socket接收数据后回调通知char command[128] = { 0 };while(1) {scanf("%s", command);std::string cmd = command;if (cmd == "quit") {break;} else {PushPacket(command); }}printf("quit mainprocess\n");
}void MainProcess::End() {for (auto &pthread : pthreads_) {pthread->StopRun();delete(pthread);pthread = nullptr;}
}// 主线程的加锁消息队列 
bool MainProcess::GetPacket(std::string &packet) {std::lock_guard<std::mutex> lockGuard(lock_);if (packets_.empty()) {return false;}packet = packets_.front();packets_.pop();return true;
}bool MainProcess::PushPacket(const std::string &packet) {// 可以加上消息队列大小限制，避免堆包导致内存暴涨不受控制 std::lock_guard<std::mutex> lockGuard(lock_);packets_.push(packet);return true;;
}WorkThread::WorkThread(MainProcess *mainpro, const std::string &thrd_name) {mainpro_ = mainpro;thread_name_ = thrd_name;
}// 启动线程,并转移给自己的成员变量,确保其生存周期 
void WorkThread::Start() {if (run_ == false) {run_ = true;std::thread thrd(WorkThread::Run, this);thd_ = std::move(thrd);} else {printf("already run.\n");}
}// 线程处理函数 
void WorkThread::Run() {std::string cmd;while(run_) {if (!mainpro_->GetPacket(cmd)) {usleep(5000);} else {Dealcmd(cmd);}}End();printf("run end, thread %s exit\n", thread_name_.c_str());
}bool WorkThread::Dealcmd(const std::string &cmd) {printf("thread %s deal command : %s\n", thread_name_.c_str(), cmd.c_str());return true;
}void WorkThread::End() {} // 控制子线程结束运行,同时采用join等待其执行完毕 
void WorkThread::StopRun() {run_ = false;thd_.join();printf("thread %s stop run\n", thread_name_.c_str());
}int main() {int thread_cnt = 5; MainProcess mp(thread_cnt);mp.Start();mp.End();printf("main quit\n");return 0;
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

以后不用记linux那一大串pthread_打头的函数了。

好耶