C++开启线程(简单封装)

此样例对原始的线程接口进行简单封装，使之更易于使用。

使用时只需继承Thread类并实现loop()函数，在需要启动线程的地方调用run()函数即可启动线程。
样例执行结果：

main.cpp

#include <iostream>

#include "Thread.h"

namespace
{
    class MyThread : public Thread
    {
        //重载线程执行函数
        const bool loop(void)
        {
            static int count = 0;
            std::cout << "count:" << count++ << std::endl;
            return 3 != count;
        }
    };
}

int main()
{
    MyThread th;
    th.run();
    
    //延时一下才能看到效果
    #ifdef WIN32
    std::this_thread::sleep_for(std::chrono::nanoseconds(10 * 1000 * 1000));
    #elif __GNUC__
    usleep(10*1000);
    #endif

    return 0;
}

Thread.h

#pragma once

#include <thread>
#include <mutex>

#define DEBUG printf("--%d-- --%s-- Debug!!\n", __LINE__, __FILE__);

class Mutex : public std::mutex
{
public:
	Mutex() {};
	~Mutex() {};

	class AutoLock
	{
		private:
			Mutex* mtx;
		public:
			AutoLock(Mutex& mutex)
			{
				mtx = &mutex;
				mtx->lock();
			}
			~AutoLock() 
			{
				mtx->unlock();
			}
	};
};

class Thread : public std::thread
{
private:
	//启动线程函数锁
	Mutex mRunMutex;

	//线程是否正在运行标志 
	bool mIsThreadRunning;
	Mutex mIsThreadRunningMutex;

	//请求退出线程函数标志
	bool mIsSetQuitThread;
	Mutex mIsSetQuitThreadMutex;

private:
	/*
	* @brife 获取线程函数是否运行状态,当未运行则标记位运行
	* @return true 线程函数为运行，标记线程位运行;false 线程函数未运行
	*/
	const bool setThreadLoopRunning(void);

protected:
	/*
	* @brife 清除请求退出线程标志
	*/
	void clearSetQuitThreadFlag(void);

public:
	Thread();
	~Thread();

	/*
	* @brife 当线程未启动时，启动线程
	* @return true 启动成功；false 启动失败 
	*/
	const bool run(void);

	/*
	* @brife 获取线程是否运行
	* @return true 线程正在运行;false 线程已经退出运行
	*/
	const bool isThreadRunning(void);

	/*
	* @brife 清除线程运行标志
	*/
	void clearIsthreadRunningFlag(void);

	/*
	* @brife 向线程置标志位退出执行
	*/
	void setQuitThread(void);

	/*
	* @brife 获取是否请求退出标志
	* @return true 当前请求退出；false 当前未请求退出
	*/
	const bool isSetQuitThread(void);

	/*
	* @brife 向线程置标志位退出执行并等待直至退出
	*/
	void setQuitThreadAndWaitForQuit(void);

	/*
	* @brife 使用者自行定义，这个函数是实际执行函数
	* @return true 再次执行此函数;false 退出执行此函数，线程执行结束
	*/
	virtual const bool loop(void) = 0;
};

Thread.cpp

#include "Thread.h"

namespace
{

	/*
	* @brife 线程执行函数
	*/
	static void threadRun(void* argc)
	{
		while (false == ((Thread*)argc)->isSetQuitThread() && ((Thread*)argc)->loop()) {}
		//清除线程正在运行标志
		((Thread*)argc)->clearIsthreadRunningFlag();
	}
}

Thread::Thread()
{
	mIsThreadRunning = false;
	mIsSetQuitThread = false;
}

Thread::~Thread()
{

}

const bool Thread::setThreadLoopRunning(void)
{
	Mutex::AutoLock lock(mIsThreadRunningMutex);
	if (false == mIsThreadRunning)
	{
		mIsThreadRunning = true;
		return true;
	}
	return false;
}

void Thread::clearSetQuitThreadFlag(void)
{
	Mutex::AutoLock lock(mIsSetQuitThreadMutex);
	mIsSetQuitThread = false;
}

const bool Thread::run(void)
{ 
	Mutex::AutoLock lock(mRunMutex);
	//设置状态失败，当前正在执行线程函数，函数返回
	if (false == setThreadLoopRunning())
	{
		return false;
	}
	//清除退出线程执行函数请求
	clearSetQuitThreadFlag();
	//开启线程
	std::thread th(threadRun, this);
	th.detach();
	return true;
}

const bool Thread::isThreadRunning(void)
{
	Mutex::AutoLock lock(mIsThreadRunningMutex);

	return mIsThreadRunning;
}

void Thread::clearIsthreadRunningFlag(void)
{
	Mutex::AutoLock lock(mIsThreadRunningMutex);

	mIsThreadRunning = false;
}

void Thread::setQuitThread(void)
{
	Mutex::AutoLock lock(mIsSetQuitThreadMutex);
	mIsSetQuitThread = true;
}

const bool Thread::isSetQuitThread(void)
{
	Mutex::AutoLock lock(mIsSetQuitThreadMutex);
	return mIsSetQuitThread;
}

void  Thread::setQuitThreadAndWaitForQuit(void)
{
	while (true == isSetQuitThread()) { setQuitThread(); }
}