C++ 线程的封装

贡献自己写的部分代码，希望能帮助到有需要的人。

代码可以在Windows/Linux下运行，可以作为一个基础类。

头文件

#ifndef THREAD_H
#define THREAD_H

class ThreadPrivate;
class Thread
{
public:
    typedef unsigned long long tid_t;

    Thread(void);
    virtual ~Thread(void);

    void start(void);
    void terminate(void);
    bool isRunning(void) const;

    static void sleep(int msec);
    static tid_t currentThreadId(void);
    static int currentProcessId(void);

protected:
    virtual void run(void) = 0;

private:
    ThreadPrivate* m_priv;

    friend class WinThread;
    friend class UnixThread;
    Thread(const Thread& rhs);
    Thread& operator=(const Thread& rhs);
};

#endif

源文件

#include <memory.h>

#ifdef WIN32
#include <Windows.h>
#else
#include <unistd.h>
#include <pthread.h>
#endif

#include "thread.h"

class ThreadPrivate
{
public:
    ThreadPrivate(Thread* thread) :
        m_isRunning(false),
        m_thread(thread)
    {}
    virtual ~ThreadPrivate(void) {
        if (m_isRunning) {
            terminate();
        }
    }

    virtual void start(void) {}
    virtual void terminate(void) {}
    bool isRunning(void) const { return m_isRunning; }

    bool m_isRunning;
    Thread* m_thread;
};

#ifdef WIN32
class WinThread : public ThreadPrivate
{
public:
    WinThread(Thread* thread) :
        ThreadPrivate(thread),
        m_tHandle(INVALID_HANDLE_VALUE)
    {}

    ~WinThread(void) {}

    virtual void start(void)
    {
        m_tHandle = ::CreateThread(NULL, 0,
                                   (LPTHREAD_START_ROUTINE)WinThreadEntry,
                                   (void*)m_thread,
                                   NULL,
                                   NULL);
    }

    virtual void terminate(void)
    {
        ::TerminateThread(m_tHandle, 0);
        m_isRunning = false;
        m_tHandle = INVALID_HANDLE_VALUE;
    }

    static DWORD WINAPI WinThreadEntry(LPVOID lp)
    {
        Thread* thread = (Thread*)lp;
        thread->m_priv->m_isRunning = true;
        thread->run();
        thread->m_priv->m_isRunning = false;
        return 0;
    }
private:
    HANDLE m_tHandle;
};

#else

class UnixThread : public ThreadPrivate
{
public:
    UnixThread(Thread* thread) :
        ThreadPrivate(thread)
    {}
    ~UnixThread(void) {}

    virtual void start(void) {
        pthread_create(&m_thread_id, NULL, UnixThreadEntry, m_thread);
    }

    virtual void terminate(void) {
        pthread_cancel(m_thread_id);
        m_isRunning = false;
    }

    static void* UnixThreadEntry(void* lp)
    {
        Thread* thread = (Thread*)lp;
        thread->m_priv->m_isRunning = true;
        thread->run();
        thread->m_priv->m_isRunning = false;
        return NULL;
    }

private:
    pthread_t m_thread_id;
};

#endif

Thread::Thread(void) : m_priv(NULL)
{
#ifdef WIN32
    m_priv = new WinThread(this);
#else
    m_priv = new UnixThread(this);
#endif
}

Thread::~Thread(void)
{
    delete m_priv;
}

void Thread::start(void)
{
    if (!isRunning()) {
        m_priv->start();
    }
}

void Thread::terminate(void)
{
    if (isRunning()) {
        m_priv->terminate();
    }
}

bool Thread::isRunning(void) const
{
    return m_priv->isRunning();
}

void Thread::sleep(int msec)
{
#ifdef WIN32
    Sleep(msec);
#else
    usleep(msec * 1000);
#endif
}

Thread::tid_t Thread::currentThreadId(void)
{
#ifdef WIN32
    return (tid_t)::GetCurrentThreadId();
#else
    pthread_t tid = pthread_self();
    tid_t thread_id = 0;
    memcpy(&thread_id, &tid, sizeof(tid_t));
    return thread_id;
#endif
}

int Thread::currentProcessId(void)
{
#ifdef WIN32
    return ::GetCurrentProcessId();
#else
    return ::getpid();
#endif
}

使用方式

class Worker : public Thread
{
public:
    Worker(void) {}
    ~Worker(void) {}
    
protected:
    virtual void run()
    {
        //work...
    }
};


int main(int argc, char **argv)
{
    //....
    Worker* worker = new Worker;
    worker->run();
    //...
    //...
}