线程与互斥锁（C++11中std::thread和std::mutex的用法）

线程

0

首先是曾经在MultiCMOS项目中用到的：

#include <thread> //包含头文件

class IDataProcessUnit
{
protected:
    bool m_processing{ false }; //线程退出标识
    std::thread m_thrProcess; //线程句柄

public:
    //数据处理流程在此
    virtual void process() {
    }

    //析构函数，对象不存在了则停止当前线程
    virtual ~IDataProcessUnit() { 
        stop(); 
    }

    //启动
    virtual bool start() {
        if (m_processing)
            return false;
        m_processing = true;
        m_thrProcess = std::thread([this](){this->process(); });
        return true;
    }
    //停止
    virtual void stop() {
        m_processing = false;
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
        if (m_thrProcess.joinable())
            m_thrProcess.join();
    }
};

重点：
线程句柄，用来唯一标识线程
线程函数，线程的入口函数。当线程执行完线程函数后，线程也会退出。如果不传入线程函数(类似这种形式std::thread t;)，线程不会运行。线程函数不能重载，否则不能编译。
线程退出标识，判断当前线程是否正在执行

1 启动一个线程的方法：

两种情况：

1. 句柄定义和线程启动分开
   线程句柄 = std::thread(参数);
2. 在定义线程句柄的同时启动线程
   std::thread m_thrProcess(参数);

几种将线程句柄与线程函数绑定到一起的情况

简单介绍一下lamda表达式：
lamda表达式表示一个可调用的代码单元。
[capture list](parameter list)->return type{function body}
capture list： 在函数中定义的局部变量的列表。
parameter list： 参数列表。
return type： 返回类型。
function body： 函数体。
可以忽略参数列表和返回类型。如：
auto f = [] {return 42;};

1. 参数可以是lamda表达式
   m_thrProcess = std::thread([this](){this->process(); });
   若process需要传进去参数，可以传递函数参数：
   m_thrProcess = std::thread([this](函数参数){this->process(函数参数); });

2. 参数可以是普通的函数（相对类的成员函数而言）
   std::thread m_thrProcess(test); //没有函数参数
   std::thread m_thrProcess(test,函数参数); //有函数参数

3. 参数可以是类的成员函数
   std::thread m_thrProcess(&类名::函数名, &类对象);
std::thread m_thrProcess(&类名::函数名, &类对象, 函数参数);

2 销毁一个线程对象

std::thread::joinable()

• 去销毁一个仍然可以“joinable”的C++线程对象会被认为是一种错误。为了销毁一个C++线程对象，要么join()函数需要被调用（并结束），要么detach()函数被调用。如果一个C++线程对象当销毁时仍然可以被join，异常会被抛出。

• 调用 join 或 detach 之前需要调用 joinable() 判断一下线程是否运行。如果 joinable() 返回 false，则不需要。

std::thread::join()
当thread::join()函数被调用后，调用它的线程会被阻塞，直到线程的执行被完成。基本上，这是一种可以用来知道一个线程已结束的机制。当thread::join()返回时，执行的线程已经完成，C++线程对象可以被销毁。
一般情况下还是请使用join而非detach。

std::thread::detach()
当thread::detach()函数被调用后，执行的线程从线程对象中被分离，已不再被一个线程对象所表达——这是两个独立的事情。C++线程对象可以被销毁，同时OS执行的线程可以继续。如果程序想要知道执行的线程何时结束，就需要一些其它的机制。join()函数在那个thread对象上不能再被调用，因为它已经不再和一个执行的线程相关联。

互斥锁

#include <mutex>

std::mutex m1; //线程互斥对象

m1.lock(); //加锁 
m1.unlock(); //解锁