C/C++编程：pthread_t 封装

短命女 2022-09-04 00:43 120阅读 0赞

# 版本1 #

*  前置知识： [Unix/Linux编程：POSIX线程的创建与退出][Unix_Linux_POSIX]

//
    // Created by oceanstar on 2021/8/9.
    //
    
    #ifndef OCEANSTAR_HTTP_THREAD_H
    #define OCEANSTAR_HTTP_THREAD_H
    
    #include <noncopyable.h>
    #include <pthread.h>
    
    namespace oceanstar{
        
        /**
     * 纯虚函数：线程任务类，该类实例的 run 方法是在子线程中被执行的
     */
        class  thread_job : public noncopyable
        {
        
            public:
            thread_job(void) {
        }
            virtual ~thread_job(void) {
        }
    
            /**
             * 纯虚函数，子类必须实现此函数，该函数在子线程中执行
             * @return {void*} 线程退出前返回的参数
             */
            virtual void* run(void) = 0;
    
            /**
             * 虚方法，在新创建的子线程中的 run() 方法被调用前调用，在同步创建
             * 线程方式下，子线程被创建后调用该虚方法，然后再通知创建这线程，
             * 从而保证在创建线程的 start() 方法返回前子线程执行初始化过程。
             */
            virtual void * init() {
         return nullptr; }
        };
    
    
        /**
         * 线程纯虚类(继承了一个纯虚类，所以它也是一个纯虚类)，该类的接口定义类似于 Java 的接口定义，子类需要实现
         * 基类的纯虚函数，使用者通过调用 thread::start() 启动线程过程
         */
        class  thread : public thread_job
        {
        
        private:
            bool detachable_;
            size_t stack_size_;
            unsigned long thread_id_;
    
            pthread_t thread_;
            void* return_arg_;
    
    
            static void* thread_run(void* arg);
    
    
        public:
            thread(void) : detachable_(false),  stack_size_(0), thread_id_(0){
        
                return_arg_ = NULL;
            }
             virtual ~thread(void){
        }
             /**
             * 当前调用者所在线程的线程 id 号
             * @return {unsigned long}
             */
            static unsigned long thread_self(void){
        
                 return (unsigned long) pthread_self();
            }
    
            /**
             * 开始启动线程过程，一旦该函数被调用，则会立即启动一个新的
             * 子线程，在子线程中执行基类 thread_job::run 过程
             * @return {bool} 是否成功创建线程
             */
            bool start();
            /**
             * 当创建线程时为非 detachable 状态，则必须调用此函数等待线程结束；
             * 若创建线程时为 detachable 状态时，禁止调用本函数
             * @param out {void**} 当该参数非空指针时，该参数用来存放
             *  线程退出前返回的参数
             * @return {bool} 是否成功
             */
            bool wait(void** out = NULL);
            /**
             * 在调用 start 前调用此函数可以设置所创建线程是否为分离 (detachable)状态；
             * 如果未调用此函数，则所创建的线程默认为非分离状态，
             *      在非分离状态下，其它线程可以 wait 本线程对象，否则禁止 wait 本线程对象；
             *      在非分离状态下，其它线程必须要 wait 本线程，否则会引起内存泄露。
             * @param yes {bool} 是否为分离状态
             * @return {thread&}
             */
            thread& set_detachable(bool yes);
        };
    }
    
    
    
    #endif //OCEANSTAR_HTTP_THREAD_H

## 使用 ##

#include <iostream>
    #include <cstring>
    #include "mythread/thread.h"
    
    
    class mythread : public oceanstar::thread{
        
    public:
        explicit mythread(bool auto_destroy = false)
                : auto_destroy_(auto_destroy)
        {
        }
        ~mythread() override = default;
    protected:
         void* init(void) {
        
            printf("--init--\n");
        }
    
        virtual void* run()
        {
        
            const char* myname = "run";
            printf("%s: thread id:  %lu\r\n", myname,  oceanstar::thread::thread_self());
            if (auto_destroy_)
                delete this;
            return NULL;
        }
    private:
        bool auto_destroy_;
    };
    
    
    static void test_thread(void) {
        
        const char *myname = "test_thread";
        mythread thr;  // 必须实现纯虚函数 【virtual void* run(void) = 0】才能创建实例
        thr.set_detachable(false);
        if (!thr.start())
        {
        
            printf("start thread failed\r\n");
            return;
        }
    
        printf("begin wait for thread exit\r\n");
        if (!thr.wait(NULL))
            printf("wait thread failed\r\n");
        else
            printf("wait thread ok\r\n");
    }
    static void test_thread2(void)
    {
        
        mythread* thr = new mythread(true);
    
        thr->set_detachable(true);
        if (!thr->start())
            printf("start thread failed\r\n");
        getchar();
    }
    
    
    int main(int argc, char *argv[])
    {
        
    
      //  test_thread();
        test_thread2();
        return (0);
    }

[Unix_Linux_POSIX]: https://blog.csdn.net/zhizhengguan/article/details/107511729