如何在类的内部创建线程并安全退出

注意两个问题:
1、线程创建之后，很多人的写法是直接一个while死循环让程序空转，这样效率低并且浪费资源；
2、当类析构的时候，一定要让线程正常退出。

ExitTHread.h

	#pragma once
	#include <iostream>
	#include <mutex>
	#include <future>
	#include <thread>
	#include <windows.h>
	using namespace std;
	
	class CExitThread
	{
	public:
		CExitThread();
		~CExitThread();

		//线程函数
		void t_Start();

		//通知线程执行
		void Notify();
	private:
		std::mutex m_Mutex_;
		std::condition_variable m_Var_;
		bool m_bReady_ = false;
		bool m_bExit_ = false;
		std::future<void> m_fuThread_;
	};

ExitTHread.cpp

	#include "ExitThread.h"
	
	CExitThread::CExitThread()
	{
		std::cout << "调用构造函数，同时创建线程.\n";
		m_fuThread_ = std::async(std::launch::async, &CExitThread::t_Start, this);
	}
	CExitThread::~CExitThread()
	{
		{
			std::unique_lock<std::mutex> locker(m_Mutex_);
			m_bReady_ = true;
		}
		m_Var_.notify_one();
		m_bExit_ = true;
		m_fuThread_.get();
		std::cout << "调用析构函数.\n";
	}
	void CExitThread::Notify()
	{
		//通知线程进行操作
		//这步类似于windows自带API WaitForSingleObject();
		{
			std::unique_lock<std::mutex> locker(m_Mutex_);
			m_bReady_ = true;
		}
		m_Var_.notify_one();
	}
	void CExitThread::t_Start()
	{
		while (true)
		{
	
			{
				std::unique_lock<std::mutex> locker(m_Mutex_);
				while (!m_bReady_) m_Var_.wait(locker);
			}
	
			//线程被通知之后，就会进入到while循环，一直循环
			//以下两句代码测试用....
			Sleep(1000);
			std::cout << "...get notify.\n";
	
			//当该线程再次被通知，且m_bExit_为true时，才退出这个while循环//
			if (m_bExit_)
				break;
		}
	
		std::cout << "Exit Thread.\n";
	}

main.cpp测试代码

	#include <iostream>
	#include <windows.h>
	#include "ExitThread.h"
	#include <memory>
	using namespace std;
	int main()
	{
		//调用类的构造函数，创建内部线程
		std::shared_ptr<CExitThread> pSensor = std::make_shared<CExitThread>();
		
		//通知类内部的线程，进入到线程中的whlie循环//
		pSensor->Notify();
		Sleep(6000);
		std::cout << "main::Hello World.\n";
		return 0;
	}

运行结果如下图所示：

当调用Notify的时候，进入到线程内部，循环打印“…process”。
pSensor跳出main函数作用域调用析构函数，退出线程。