C++11线程管理基础

1. 启动线程

在C++ 11中线程是在std::thread对象创建时启动。因为我们把启动线程的重心放在如何构造这个thread对象，其构造函数有以下几个：

//仅仅是构造一个线程类，但没有和具体化的线程函数关联
thread() noexcept;
// 移动构造函数
thread( thread&& other ) noexcept;
//构造新的 std::thread 对象并将它与执行线程关联
template< class Function, class... Args >
explicit thread( Function&& f, Args&&... args );

其中f是任意一个可调用对象，包括普通函数、函数对象 、lambda表达式等，args是传递给线程函数的参数。

需要特别注意的是，传到线程函数的参数默认是按值传递或者被移动的，若需要传递引用参数给线程函数，则必须包装它（例如用 std::ref 或 std::cref ）。

启动线程的核心代码：

//代码清单 1
//函数对象 
class background_task
{
public:
    background_task(int number, char* pszName) :
        m_nNumber(number),
        m_pszName(pszName){}

    ~background_task(){}

    void operator()() const
    {
        std::this_thread::sleep_for(std::chrono::seconds(2));
        //分离式情况下，m_pszName是非法指针
        std::cout << "number is: " << m_nNumber << " name is:  " << m_pszName << std::endl;
    }
private:
    int         m_nNumber;
    std::string m_strName;
    char*       m_pszName;
};
// t1 非线程
std::thread t1; 

//使用普通函数进行构造线程,按值传递
void f1(int n){std::cout << n << std::endl;}
std::thread t2(f1, 10);

//使用函数对象构造线程，使用引用
background_task task(12, "jimmy");
std::thread run_task(std::ref(task));

2.等待线程完成或者分离

当我们启动了一个线程，我们需要明确是要等待线程结束(加入式)，还是让其自主运行(分离式)。即线程对象退出之前必须明确调用join或detach,否则会崩溃。需要注意的是，必须在std::thread对象销毁之前做出决定，否则你的程序将会终止(std::thread的析构函数会调用std::terminate()，这时再去决定会触发相应异常)。如下代码，既没调用

join又没detach，程序崩溃：

#include <memory>
#include <string>
#include <iostream>
#include <thread>

//代码清单 1
//函数对象 
class background_task
{
public:
	background_task(int number, char* pszName) :
		m_nNumber(number),
		m_pszName(pszName) {}

	~background_task() {}

	void operator()() const
	{
		std::this_thread::sleep_for(std::chrono::seconds(2));
		//分离式情况下，m_pszName是非法指针
		std::cout << "number is: " << m_nNumber << " name is:  " << m_pszName << std::endl;
	}
private:
	int         m_nNumber;
	std::string m_strName;
	char*       m_pszName;
};

//使用普通函数进行构造线程,按值传递
void f1(int n) { std::cout << n << std::endl; }

int main()
{
	// t1 非线程
	std::thread t1;


	std::thread t2(f1, 10);
	{
		//使用函数对象构造线程，使用引用
		/*char* p = const_cast<char*>("jimmy");*/
		char p[] = "jimmy";
		background_task task(12, p);
		/*std::thread run_task(std::ref(task));*/
		std::thread run_task(std::ref(task));
	}
	getchar();
	return 0;
}

如果线程是加入式的，我们需要调用std::thread的类成员函数join(),等待线程结束，然后再执行join()之后的代码。

如果不等待线程，我们需要调用std::thread的类成员函数detach(),此时就必须保证线程结束之前，可访问的数据得有效性。否则会产生未定义行为，或者不符合预期的值产生。这个是因为线程函数还持有函数局部变量的指针或者引用。

//代码清单 2
//危险代码示例
int _tmain(int argc, _TCHAR* argv[])
{
    {
        std::cout << "enter local  zone..." << std::endl;

        char *buffer = new char[128]; 
        sprintf(buffer, "%s", "this is thread...\n");
		//传入指针，在函数对象中引用了指针
        background_task task(12, buffer);
        std::thread   run_task(std::ref(task));
        //加入式，此时等到线程结束，指针一直有效
        //run_task.join();
        //分离式，主线程不等创建的新线程，指针提前释放，存在非法行为
        run_task.detach();
        
        //释放指针
        delete[] buffer;
        buffer = NULL;
        
        std::cout << "leave local  zone..." << std::endl;
    }

    std::this_thread::sleep_for(std::chrono::seconds(5));
}

运行结果：

加入式运行结果符合预期，分离式引用了非法内存值，结果异常，更严重时会因此崩溃形为。

3.后台运行线程

当我们调用std::thread成员函数detach()后，会让执行线程在后台运行，此时主线程不能与之产生直接交互，并且不会等待这个线程执行结束，此时相关thread对象就无法被加入。

不过C++运行库保证，当线程退出时，相关资源的能够正确回收，后台线程的归属和控制C++运行库都会处理。

background_task task(12, buffer);
std::thread   run_task(std::ref(task));
run_task.detach();
//在清单2中增加get_id()以及joinalbe()测试接口
std::cout << "detach thread id : " << run_task.get_id() << std::endl;
std::cout << "detach thread joinable status: " << run_task.joinable() << std::endl;

 执行结果：

detach thread id : 0
detach thread joinable status: 0

 当我调用detach()成员函数之后，相应的std::thread对象就与实际执行的线程无关了，就不能再调用join()成员函数，否则会抛异常。同时线程ID值也被设置成为0.

如下代码：

int main()
{
	// t1 非线程
	std::thread t1;


	std::thread t2(f1, 10);
	{
		//使用函数对象构造线程，使用引用
		/*char* p = const_cast<char*>("jimmy");*/
		char p[] = "jimmy";
		background_task task(12, p);
		/*std::thread run_task(std::ref(task));*/
		std::thread run_task(std::ref(task));
        run_task.detach();
	}
	getchar();
	return 0;
}

run_task出了大括号后被析构，但线程的执行函数对象不会因为对象被析构而崩溃、不执行 

4.特殊情况下的等待

如果我们应用程序必须等待某个线程，我们则需要细心挑选调用join()的位置。当在线程运行之后产生异常，在join()调用之前抛出或者返回，就意味着这次join()调用会被跳过,为了避免产生没有调用join的情况，我们需要在可能的函数返回地方都加上join等待。

例如

int _tmain(int argc, _TCHAR* argv[])
{
    background_task task(12, "this is testing cpp");
    std::thread   run_task(std::ref(task));

    try
    {
        do_other_something();
    }
    catch (...)
    {
        run_task.join();
        return 1;
    }
    
    if (!check_user_intput())
    {
        run_task.join();
        return 1;
    }
   
    if (!process_user_data())
    {
        run_task.join();
        return 1;
    }

    run_task.join();
    
    return 0;
}

使用这种方式，虽然可以解决问题，但这种编码方式是不可靠或者不简洁的，如果后续新增代码，异常处忘记添加join()等待就直接返回，则隐藏了bug，不利于后续问题定位。

我们希望无论正常与否，可以提供一个简洁的机制,确保程序返回前都可以保障调用join(), 这种方式就叫RAII(资源获取即初始化方式，Resource Acquisition Is Initialization).我们在提供一个类，在析构函数中使用join().

//线程类的RAII
class thread_guard
{
public:
    explicit thread_guard(std::thread& t_) :
        t(t_){}
    ~thread_guard()
    {
        if (t.joinable()) // 1 这个线程可以加入
        {
            t.join();      // 2等待线程结束
            std::cout << "thread is end..." << std::endl;
        }
    }

    thread_guard(thread_guard const&) = delete;   // 3
    thread_guard& operator=(thread_guard const&) = delete;
    
private:
    std::thread& t;
};
//test code
int _tmain(int argc, _TCHAR* argv[])
{
    background_task task(12, "this is testing cpp");
    std::thread   run_task(std::ref(task));
    //thread_guard 对象析构后 会检查run_task对象的是否可以加入，
    //如果可以加入则等待线程结束在析构自身,确保线程本身以简洁的方式结束
    thread_guard guard(run_task);
    try
    {
        do_other_something();
    }
    catch (...)
    {
        return 1;
    }
    
    if (!check_user_intput())
    {
        return 1;
    }

    if (!process_user_data())
    {
        return 1;
    }
	
	return 0;
}

在thread_guard的析构函数的测试中，首先判断线程是否已加入①，如果没有会调用join()②进行加入。这很重要，因为join()只能对给定的对象调用一次，所以对给已加入的线程再次进行加入操作时，将会导致错误。thread_guard保障线程无论如何都会等待线程结束。