C/C++开发，无可避免的多线程（篇五）.实现自己的线程封装类

已于 2023-03-15 00:05:44 修改
阅读量1.4k 收藏 12
点赞数 1
分类专栏： c/c++开发进阶及实战案例 文章标签： c++ 多线程 pthread_t std thread c语言
于 2023-03-06 18:32:57 首次发布
本文为CSDN“py_free-物联智能”博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/py8105/article/details/129363133
版权
文章详细介绍了如何在C++98和C++11标准下封装线程类MyThread，包括线程的启动、停止、状态获取等方法。在C++98中，线程功能依赖于pthread库，而在C++11中则使用std::thread。作者通过创建派生类实现具体业务逻辑，并提供了测试用例展示线程的启动和停止。文章最后讨论了如何将这两个版本合并在一个类中，以适应不同的编译环境。
摘要由CSDN通过智能技术生成

目录

一、c++11以前的线程封装版本

        1.1 mythread_c98实现设计

        1.2 MyThread派生类-真正业务实现

        1.3 线程类调用测试

 二、c++11后的线程封装版本

         2.1 mythread_c11线程实现

        2.2 mythread_c11线程调用测试

三、合而为一

        3.1 mythread混合版本实现

        3.2 混合版本调用及编译测试

一、c++11以前的线程封装版本

        在本专栏的多线程课题第一篇就说过，c++11标准前，实现多线程事务是由调用的<pthread.h>头文件的线程相关功能函数来实现的。

        现在通过<pthread.h>的pthread_create、pthread_join、pthread_exit等功能函数来封装一个线程类MyThread：

        1）MyThread可以被继承，具有run线程函数，该函数为虚函数，可以被派生类重写

        2）线程类启动start、停止stop的成员函数，可以管理线程线程函数运行或退出（run函数）能力

        3）可以获得线程的状态、线程编号相关信息。

        1.1 mythread_c98实现设计

        为此，本博文创建mythread_c98.h头文件，设计该线程类MyThread内容如下：

#ifndef _MYTHREAD_C98_H_
#define _MYTHREAD_C98_H_

#include <pthread.h>    //pthread_t
#include <unistd.h>     //usleep

class MyThread
{
public:
    // constructed function
    MyThread();
    virtual ~MyThread();
    //the entity for thread running
    virtual int run()=0;

    //start thread
    bool start();
    //wait for thread end in limit time(ms)
    void stop(unsigned long millisecondTime=0);

    //get thread status
    int state();
    //gte thread ID
    pthread_t getThreadID();
private:
    //current thread ID
    pthread_t tid;
    //thread status
    enum THREAD_STATUS
    {
        THREAD_STATUS_NEW       = 0,      //threadStatus-new create
        THREAD_STATUS_RUNNING   = 1,  //threadStatus-running
        THREAD_STATUS_EXIT      = -1     //threadStatus-end
    };
    THREAD_STATUS threadStatus;
    //get manner pointer of execution 
    static void* run0(void* pVoid);
    //manner of execution inside
    void* run1();
    //thread end
    void join();
};

#endif /* _MYTHREAD_C98_H_*/

        线程类通过一个枚举THREAD_STATUS设置线程的开启、运行、结束三个状态。start函数会调用pthread_create新创建一个线程，并调用run函数，而stop函数会调用pthread_join停止线程，线程类析构函数则调用pthread_exit来让线程销毁，具体实现如下：

#include "myThread_c98.h"

#include <stdio.h>

void* MyThread::run0(void* pVoid)
{
    MyThread* p = (MyThread*) pVoid;
    p->run1();
    return p;
}

void* MyThread::run1()
{
    threadStatus = MyThread::THREAD_STATUS_RUNNING;
    tid = pthread_self();
    printf("thread is run, tid(%d)!\n",tid);
    this->run();
    return NULL;
}

MyThread::MyThread()
{
    tid = 0;
    threadStatus = MyThread::THREAD_STATUS_NEW;
}

MyThread::~MyThread()
{
    printf("thread is ~MyThread!\n");
    threadStatus = MyThread::THREAD_STATUS_EXIT;
    tid = 0;
    pthread_exit(NULL);
}

int MyThread::run()
{
    while( MyThread::THREAD_STATUS_RUNNING == threadStatus )
    {
        printf("thread is running!\n");
        sleep(10);
    }
    return 0;
}

bool MyThread::start()
{
    return pthread_create(&tid, NULL, run0, this) == 0;
}

pthread_t MyThread::getThreadID()
{
    return tid;
}

int MyThread::state()
{
    return (int)threadStatus;
}

void MyThread::join()
{
    threadStatus = MyThread::THREAD_STATUS_EXIT;
    if (tid > 0)
    {
        void * pth_join_ret = NULL;
        int ret = pthread_join(tid, &pth_join_ret);
        printf("thread is join, tid(%d)!\n",tid);
        if(0!=ret)
            printf("pthread_join tid(%d) error:%s\n",(char*)pth_join_ret);
        pthread_cancel(tid);
        tid = 0;
    }
}
//等待millisecondTime(ms)后关闭线程
void MyThread::stop(unsigned long millisecondTime)
{
    if (tid == 0)
    {
        return;
    }else{
        printf("thread is join tid(%d) for time(%lu)!\n",tid,millisecondTime);
        unsigned long k = 0;
        while (k < millisecondTime)
        {
            usleep(1000);//等待1毫秒
            k++;
        }
        join();
    }
}

        PS，pthread_exit一般是子线程调用，用来结束当前线程，一般在该线程中自己调用退出采用pthread_exit函数；pthread_join一般是主线程来调用，用来等待子线程退出，因为是等待，所以是阻塞的。外部线程调用该线程做退出处理，采用pthread_join函数来实现。

        1.2 MyThread派生类-真正业务实现

        因为MyThread的run函数是虚函数，因此不能直接使用MyThread创建线程对象，而是需要先创建MyThread类的派生类，通过派生类重新实现run函数（即实际任务实现），再通过派生构建线程对象来使用。

        下来看看如何应用MyThread线程类。创建test1.h、test1.cpp源文件，创建MyThread类的派生类MyThreadTest如下：

//test1.h
#ifndef _TEST_1_H_
#define _TEST_1_H_
#include "mythread_c98.h"

class MyThreadTest : public MyThread
{
public:
    int run();
};
#endif
//test1.cpp
#include "test1.h"
#include <stdio.h>

int MyThreadTest::run()
{
    int index_test = 0;
    while (1==this->state())
    {
        printf("MyThreadTest is %d running!\n",++index_test);
        usleep(1000);
    }
    return 0;
};

        派生类MyThreadTest仅仅是重写了run函数，这里的任务是没间隔1毫秒打印一句文字。

        1.3 线程类调用测试

        然后将在main.cpp函数中使用该派生类。

//main.cpp
#include "test1.h"
#include <stdio.h>

int main(int argc, char* argv[])
{
    MyThreadTest th;
    th.start();
    th.stop(10);
    sleep(1);
    th.start();
    th.stop(10);
    printf("main is finish!\n");
    return 0;
};

        上述这段代码，实现了线程两次启停测试，每次是一旦启动start后，立刻调用stop去延时10毫秒结束线程，前后两次测试等待了1秒时间。现在编译测试一下（相关编译环境搭建可以看参看前面博文：C/C++开发，无可避免的多线程（篇一）.跨平台并行编程姗姗来迟_py_free-物联智能的博客-CSDN博客），首选是win下，采用的MinGW编译工具，编译时特别指定了采用c++98标准，g++ main.cpp mythread_c98.cpp test1.cpp -o test.exe -std=c++98（linux下记得加上-lpthread哦），是正确达成期望的运行结果：

         然后也在Linux编译环境测试了一下，本博文采用的是cygwin64编译工具，同样达到一样的效果。

        有了上述这个线程封装类，在很多小项目编程中就可以直接采用它派生一个子类，将要实现的业务在run重写，需要的话，可以通过线程状态和子类成员变量共同判断循环条件，就可以快速实现自己的多线程了。另外使用完该线程，也直接析构也达到停止及退出循环。

 二、c++11后的线程封装版本

         2.1 mythread_c11线程实现

        下来采用c++11标准库里的线程支持库来实现和上面示例代码基本一致的功能。为了和前面保持一致，先将前面的mythread_c98.h和mythread_c98.cpp拷贝一份，重命名为mythread_c11.h和mythread_c11.cpp源文件，mythread_c11.h调整内容如下，就做了三处微调，代码中已经标注出来:

#ifndef _MYTHREAD_C11_H_
#define _MYTHREAD_C11_H_

#include <thread>       //std::thread,c11时调整部分
#include <unistd.h>     //usleep

class MyThread
{
public:
    // constructed function
    MyThread();
    virtual ~MyThread();
    //the entity for thread running
    virtual int run()=0;

    //start thread
    bool start();
    //wait for thread end in limit time(ms)
    void stop(unsigned long millisecondTime=0);

    //get thread status
    int state();
    //gte thread ID
    std::thread::id getThreadID(); //c11时调整部分
private:
    //current thread ID
    std::thread* tid;           //c11时调整部分
    //thread status
    enum THREAD_STATUS
    {
        THREAD_STATUS_NEW       = 0,     //threadStatus-new create
        THREAD_STATUS_RUNNING   = 1,     //threadStatus-running
        THREAD_STATUS_EXIT      = -1     //threadStatus-end
    };
    THREAD_STATUS threadStatus;
    //get manner pointer of execution 
    static void* run0(void* pVoid);
    //manner of execution inside
    void* run1();
    //thread end
    void join();
};

#endif /* _MYTHREAD_C11_H_ */

        然后再来看线程类的实现部分，无非就是将 c++98支持的pthread_create、pthread_join、pthread_exit等功能函数替换成c++11的std::thread来实现。

#include "myThread_c11.h"

#include <stdio.h>

void* MyThread::run0(void* pVoid)
{
    MyThread* p = (MyThread*) pVoid;
    p->run1();
    return p;
}

void* MyThread::run1()
{
    threadStatus = MyThread::THREAD_STATUS_RUNNING;
    printf("thread is run, tid(%d)!\n",tid->get_id());
    this->run();
    return NULL;
}

MyThread::MyThread()
{
    tid = nullptr;
    threadStatus = MyThread::THREAD_STATUS_NEW;
}

MyThread::~MyThread()
{
    printf("thread is ~MyThread!\n");
    threadStatus = MyThread::THREAD_STATUS_EXIT;
    delete tid;
    tid = nullptr;
}

int MyThread::run()
{
    while( MyThread::THREAD_STATUS_RUNNING == threadStatus )
    {
        printf("thread is running!\n");
        sleep(10);
    }
    return 0;
}

bool MyThread::start()
{
    tid = new std::thread(run0,this);
    return (nullptr!=tid);
}

std::thread::id MyThread::getThreadID()
{
    if(nullptr==tid)
        return std::thread::id();
    return tid->get_id();
}

int MyThread::state()
{
    return (int)threadStatus;
}

void MyThread::join()
{
    threadStatus = MyThread::THREAD_STATUS_EXIT;
    if (nullptr!=tid)
    {
        tid->join();
        delete tid;
        tid = nullptr;
    }
}
//等待millisecondTime(ms)后关闭线程
void MyThread::stop(unsigned long millisecondTime)
{
    if (tid == 0)
    {
        return;
    }else{
        printf("thread is join tid(%d) for time(%lu)!\n",tid->get_id(),millisecondTime);
        unsigned long k = 0;
        while (k < millisecondTime)
        {
            usleep(1000);//等待1毫秒
            k++;
        }
        join();
    }
}

        上述代码相对c++98的实现几乎没什么变化，就是原来涉及到pthread_create、pthread_join、pthread_exit的start函数、析构函数、join函数做了调整，原来tid是采用0来初始赋值的，现在转用了c++11支持的nullptr，其他地方几乎保持不变，打印输出的线程id通过std::thread的成员函数tid->get_id()来实现。

        2.2 mythread_c11线程调用测试

        然后再看调用方面，还是采用前面的派生类及调用例子，test1.h和test1.cpp，就仅仅需要修改一下test1.h对头文件的引用，其他保持不变：

//test1.h
#ifndef _TEST_1_H_
#define _TEST_1_H_
//#include "mythread_c98.h"//注释
#include "mythread_c11.h"//采用c++11的实现

class MyThreadTest : public MyThread
{
public:
    int run();
};
#endif
//test1.cpp
#include "test1.h"
#include <stdio.h>

int MyThreadTest::run()
{
    int index_test = 0;
    while (1==this->state())
    {
        printf("MyThreadTest is %d running!\n",++index_test);
        usleep(1000);
    }
    return 0;
};

        测试调用代码main.cpp全部不变：

#include "test1.h"
#include <stdio.h>

int main(int argc, char* argv[])
{
    MyThreadTest th;
    th.start();
    th.stop(10);
    sleep(1);
    th.start();
    th.stop(10);
    printf("main is finish!\n");
    return 0;
};

        编译指令：g++ main.cpp mythread_c11.cpp test1.cpp -o test.exe -std=c++11（linux下记得加上-lpthread哦），运行测试成如下，同样达到目的，咋不说，使用的人根本不知道内部做了调整：

         同样linux编译环境也测试一下，OK：

         其实上述代码还可以进一步优化，枚举类型的线程状态毕竟涉及到本线程及可能外部线程调用，因此如果采用原子类型std::atomic来表述也不错的，可以解决几乎不会触发的线程数据安全问题。

三、合而为一

        很多时候，在实际项目中，有些模板使用c++98标准库，有些模块使用c++11以上标准库，虽然说支持c++98的在c++11编译环境也是OK的：g++ main.cpp mythread_c98.cpp test1.cpp -o test.exe -std=c++11。但是如此相似的两个线程类版本，是很容易合并在一起的，通过宏编译条件，c++98和c++11两不误。

        3.1 mythread混合版本实现

        再次拷贝一份mythread_c98.h、mythread_c98.cpp并重命名为mythread.h、mythread.cpp源文件，然后根据__cplusplus宏进行条件编译设置：

        mythread.h内容如下，和前面c98、c11的相比，就是根据__cplusplus宏定义一些c98、c11编译环境下归一化别名：

#ifndef _MYTHREAD_H_
#define _MYTHREAD_H_

#if __cplusplus < 201103L
#include <pthread.h>        //pthread_t
#define nullptr 0
typedef pthread_t ThreadID;
typedef pthread_t RThreadID;
#else
#include <thread>           //std::thread,c11时调整部分
typedef std::thread* ThreadID;
typedef std::thread::id RThreadID;
#endif
#include <unistd.h>         //usleep

class MyThread
{
public:
    // constructed function
    MyThread();
    virtual ~MyThread();
    //the entity for thread running
    virtual int run()=0;

    //start thread
    bool start();
    //wait for thread end in limit time(ms)
    void stop(unsigned long millisecondTime=0);

    //get thread status
    int state();
    //get thread ID
    RThreadID getThreadID();    //调整
private:
    //current thread ID
    ThreadID tid;        //调整
    //thread status
    enum THREAD_STATUS
    {
        THREAD_STATUS_NEW       = 0,      //threadStatus-new create
        THREAD_STATUS_RUNNING   = 1,  //threadStatus-running
        THREAD_STATUS_EXIT      = -1     //threadStatus-end
    };
    THREAD_STATUS threadStatus;
    //get manner pointer of execution 
    static void* run0(void* pVoid);
    //manner of execution inside
    void* run1();
    //thread end
    void join();
};

         mythread.cpp，定义文件内容可能会麻烦一下，需要将根据宏条件改写c98和c11不同之处的代码，但前面都曾实现过，仅仅麻烦下，倒不难。

#include "myThread.h"

#include <stdio.h>

void* MyThread::run0(void* pVoid)
{
    MyThread* p = (MyThread*) pVoid;
    p->run1();
    return p;
}

void* MyThread::run1()
{
    threadStatus = MyThread::THREAD_STATUS_RUNNING;
    #if __cplusplus < 201103L
    tid = pthread_self();
    printf("thread is run, tid(%d)!\n",tid);
    #else
    printf("thread is run, tid(%d)!\n",tid->get_id());
    #endif
    this->run();
    return nullptr;
}

MyThread::MyThread()
{
    tid = nullptr;
    threadStatus = MyThread::THREAD_STATUS_NEW;
}

MyThread::~MyThread()
{
    printf("thread is ~MyThread!\n");
    threadStatus = MyThread::THREAD_STATUS_EXIT;
    #if __cplusplus < 201103L
    pthread_exit(NULL);
    #else
    delete tid;
    #endif
    tid = nullptr;  
}

int MyThread::run()
{
    while( MyThread::THREAD_STATUS_RUNNING == threadStatus )
    {
        printf("thread is running!\n");
        sleep(10);
    }
    return 0;
}

bool MyThread::start()
{
    #if __cplusplus < 201103L
    return pthread_create(&tid, NULL, run0, this) == nullptr;
    #else
    return (nullptr!=(tid = new std::thread(run0,this)));
    #endif
    
}

RThreadID MyThread::getThreadID()
{
    #if __cplusplus < 201103L
    return tid;
    #else
    return (nullptr==tid)?std::thread::id():tid->get_id();
    #endif
}

int MyThread::state()
{
    return (int)threadStatus;
}

void MyThread::join()
{
    threadStatus = MyThread::THREAD_STATUS_EXIT;
    if (nullptr!=tid)
    {
        #if __cplusplus < 201103L
        int ret = pthread_join(tid, nullptr);
        pthread_cancel(tid);
        #else
        tid->join();
        delete tid;
        #endif
        tid = nullptr;
    }
}
//等待millisecondTime(ms)后关闭线程
void MyThread::stop(unsigned long millisecondTime)
{
    if (nullptr == tid)
    {
        return;
    }else{
        #if __cplusplus < 201103L
        printf("thread is join tid(%d) for time(%lu)!\n",tid,millisecondTime);
        #else
        printf("thread is join tid(%d) for time(%lu)!\n",tid->get_id(),millisecondTime);
        #endif
        unsigned long k = 0;
        while (k < millisecondTime)
        {
            usleep(1000);//等待1毫秒
            k++;
        }
        join();
    }
}

        这样就达成了c++98和c++11标准库版本下的统一。

        3.2 混合版本调用及编译测试

        还是利用前面的测试例子进行测试一下，调整test1.h的头文件应用，其保持不变：

//test1.h
#ifndef _TEST_1_H_
#define _TEST_1_H_
// #include "mythread_c98.h"
// #include "mythread_c11.h"
#include "mythread.h"

class MyThreadTest : public MyThread
{
public:
    int run();
};
#endif
//test1.cpp
#include "test1.h"
#include <stdio.h>

int MyThreadTest::run()
{
    int index_test = 0;
    while (1==this->state())
    {
        printf("MyThreadTest is %d running!\n",++index_test);
        usleep(1000);
    }
    return 0;
};

        线程的调用在main.cpp内，保持原来一致，也不需要作出任何调整：

#include "test1.h"
#include <stdio.h>

int main(int argc, char* argv[])
{
    MyThreadTest th;
    th.start();
    th.stop(10);
    sleep(1);
    th.start();
    th.stop(10);
    printf("main is finish!\n");
    return 0;
};

        再次编译，可以指定标准库版本，也可以不指定，都能得到正确编译结果（linux下记得加上-lpthread哦）：

        1）g++ main.cpp mythread.cpp test1.cpp -o test.exe -std=c++98

        2）g++ main.cpp mythread.cpp test1.cpp -o test.exe -std=c++11

        3）g++ main.cpp mythread.cpp test1.cpp -o test.exe

        运行编译输出程序：

        这样一个基本的满足c++98、c++11标准库混合编译环境的线程类就做好了，在一般小型项目内，通过继承它，做一些简要调整就能快速应用多多线程开发中。

py_free-物联智能
关注
专栏目录
C++代码实现FFmpeg编码+线程+http
weixin_64144091的博客
07-08 908
/ 添加视频流,视频流对应的结构体,用于视频编解码===========================================// 创建输出封装器上下文=====================================// 写输出文件头信息==============================// 配置编码器参数==========================// 找到编码器======================// 打开编码器上下文==================
Linux 多线程服务器端编程：使用 muduo C++ 网络库
SimonxxSun的博客
10-15 1199
目录 一、线程同步精要 互斥器 mutex 条件变量 封装 MutexLock、MutexLockGuard 和 Condition 线程安全的 Singleton 实现 mutex 与 shared_ptr 的应用实例 一、线程同步精要 并发编程的两种基本模型：message passing 和 shared memory。 线程同步的四项原则： 尽量最低限度的共享对象...
C++11 封装线程类
田螺姑娘的博客
11-27 834
在我们的日常开发过程中，难免会开线程，那为何不将其封装为一个类对象，而我们在使用的过程中也不需要在书写一些重复的代码，只需实例化类对象即可使用。
最简单的C++ 线程封装
05-27
实现了各个平台下的线程封装，只需要继承这个基类，实现一个Run方法，就可以实现对象化的线程类，支持Windows Linux MAC
C C++ 线程池的简单封装_c++ 线程封装
最新发布
2401_87255883的博客
09-22 231
如果项目需要频繁的创建线程来处理任务，那么CPU资源会在线程创建和销毁上浪费许多，所以我们可以先把一定量的线程先创建好并且让它们在没任务的情况下陷入睡眠，有任务时再被唤醒来处理任务；最近在搭建一个服务器，打算把线程池应用进去，根据老师课上所讲和网上前辈们提供的资料对线程池有了以下总结：**（4） 任务队列： 存放没用处理的任务，提供一种缓冲机制。（3） 任务接口（任务类内）：供线程调度进行任务的执行。（1） 线程池管理器： 对线程进行创建与管理。（2） 工作线程： 线程池中的线程。
C++ Thread对象封装
浮白
04-02 6181
Pthread库是posix linux的线程库，调用接口如下，我们模仿JDK，对Thread进行封装，具体的业务逻辑只需要如同Thread一样实现run方法即可。 线程操纵函数（简介起见，省略参数） pthread_create()：创建一个线程 pthread_exit()：终止当前线程 pthread_cancel()：中断另外一个线程的运行 pthread
C++线程的封装
好好学习，天天向上
07-19 1629
在C中创建线程一般是差不多以下这种形式: void* thread_proc(void* arg){ //线程执行过程 } int main(void){ pthread_t tid; pthread_create(&tid,NULL,thread_proc,...); return 0; } 当我们要用C++把其封装成类的时候，可能会写出这样的程序： class Thread{...
C++线程类的封装
pan_1214_的博客
04-24 819
操作系统：ubuntu20.04LTS使用头文件：pthread.h在之前的文章中已经实现了C++不可复制基类和线程同步类的封装，本文章内容实现对线程的封装。
安卓系统层开发之C++
Gordon的博客
06-13 376
安卓系统层开发，职业生涯新起点。
C++学习笔记总结(二)
LHL1999_12_14的博客
07-31 407
thread、condition、mutex、atomic、function、bind、使用新特性实现线程池（支持可变参数列表）异常协程
线程封装类
05-18
自己封装的线程类，可实现启动，暂停，退出线程功能，经过本人验证，非常好用。
C++线程的高级封装, 支持对类成员函数开启线程
04-16
示例: Thread t1; t1.Start(ThreadStart(&ThreadFunction, (void*)1)); t1.Join(); Test test; // 类, ThreadMethod为非静态成员 Thread t2; t2.Start(ThreadStart(&test, &Test::ThreadMethod)); t2.Join();
《剑指Java面试-Offer直通车》--Java多线程与并发
lucky_jiexia的博客
05-02 4340
进程和线程的区别
C++ 线程类封装
qq_35003588的博客
11-17 612
#ifndef _THREAD_H #define _THREAD_H /// @brief 线程 class Thread { public: /// @brief 析构器 virtual ~Thread (void) {} /// @brief 启动线程 void start (void); private: /// @brief 线程过程函数 ...
C++封装一个简单的线程类
zs10hz的专栏
08-05 878
多线程编程简介：     大家在编程时，经常需要在程序中启动一个或多个线程来处理任务，而如果每次都是去调用系统创建线程的API函数来创建，代码量虽不多，但线程的创建和业务逻辑代码就揉在一起了，且创建多个线程的时候，有大量的重复代码，不便于维护。若我们把创建线程和销毁线程的这些共同的代码封装到一个类中，这样我们可以更专注业务逻辑的实现，在其它地方直接拿来用就行，程序也便于维护和扩展。而且这样的
c++封装线程
linuxcprimerapue的博客
07-29 676
线程库类型 Linux线程库有两个流行的线程库，分别是LinuxThreads和NPTL，由于LinuxThreads的某些缺点，已经被NPTL取代，它们都是基于1：1模式实现，即1个用户线程被映射为1个内核线程；故每一个用户线程在内核中有唯一的标识； 线程标识 使用pthread_t存在问题 void* loop(void*) {
封装一个C++的线程类
weixin_44797811的博客
02-28 1035
封装一个C++的线程类
C++ 线程的封装
热门推荐
被遗忘de角落
12-01 3万+
贡献自己写的部分代码，希望能帮助到有需要的人。 代码可以在Windows/Linux下运行，可以作为一个基础类。 头文件 #ifndef THREAD_H #define THREAD_H class ThreadPrivate; class Thread { public: typedef unsigned long long tid_t; Thread
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

py_free-物联智能

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值