C++ 线程的封装

落日映苍穹つ 2022-06-04 02:14 232阅读 0赞

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

**代码可以在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();
        //...
        //...
    }