一个简单实用的线程基类

#pragma once
#pragma warning ( disable : 4251 )

#include <string>
#include <Windows.h>

#ifndef NDEBUG
#define THREAD_BASE_ASSERT(condition) if (!(condition)) { DebugBreak(); }
#else
#define THREAD_BASE_ASSERT(condition) ((void)0)
#endif

/**
线程基类，提供线程启动（异步）、结束（同步）的功能
*/
class CThreadBase
{
public:
    CThreadBase();
    virtual ~CThreadBase();

public:
    /**
    @name 启动线程
    @param strParam 透传给OnRun函数
    @return 成功 或 失败
    */
    bool Start(const std::string& strParam);

    /**
    @name 同步结束线程
    @param strParam 透传给OnRun函数
    @return 成功 或 失败
    */
    void Stop();

    /**
    @name 查询是否处于运行中
    */
    bool IsRunning();

protected:
    //子类可以覆盖，Start时会调OnStart, strParam与Start参数相同
    virtual bool OnStart(const std::string& strParam);

    //子类可以覆盖，线程启动后会调用OnRun, strParam与Start参数相同
    virtual void OnRun(const std::string& strParam);

    //子类可以覆盖，线程结束时调用
    virtual void OnStop() { }

private:
    static void ThreadEntry(CThreadBase* pThis, std::string strParam);

private:
    bool m_bRunning = false;
    HANDLE m_hSyncStop = NULL;
};

#include "ThreadBase.h"
#include <future>

using namespace std;

CThreadBase::CThreadBase()
{
}

CThreadBase::~CThreadBase()
{
    if (m_bRunning)
    {
        THREAD_BASE_ASSERT(false);   //should not reach here
        Stop();
    }
}

bool CThreadBase::Start(const std::string& strParam)
{    
    if (m_bRunning)
    {
        THREAD_BASE_ASSERT(false);   //should not reach here
        Stop();
    }

    if (!OnStart(strParam))
    {
        return false;
    }

    if (m_hSyncStop != NULL)
    {
        THREAD_BASE_ASSERT(false);   //should not reach here
        CloseHandle(m_hSyncStop);
    }
    m_hSyncStop = CreateEvent(NULL, TRUE, FALSE, NULL);
    m_bRunning = true;
    async(launch::async, &CThreadBase::ThreadEntry, this, strParam);
    return true;
}

void CThreadBase::Stop()
{
    if (!m_bRunning)
    {
        return;
    }

    OnStop();

    THREAD_BASE_ASSERT(m_hSyncStop != NULL);
    WaitForSingleObject(m_hSyncStop, INFINITE);
    CloseHandle(m_hSyncStop);
    m_hSyncStop = NULL;
    m_bRunning = false;
}

bool CThreadBase::IsRunning()
{
    return m_bRunning;
}

bool CThreadBase::OnStart(const std::string& strParam)
{
    (void)strParam;
    return true;
}

void CThreadBase::OnRun(const std::string& strParam)
{
    (void)strParam;
    THREAD_BASE_ASSERT(false);   //should not reach here
}

void CThreadBase::ThreadEntry(CThreadBase* pThis, std::string strParam)
{
    pThis->OnRun(strParam);
    THREAD_BASE_ASSERT(pThis->m_hSyncStop != NULL);
    SetEvent(pThis->m_hSyncStop);
}