【Linux】：线程库简单封装

? 之前我们在这篇博客 里面已经学习了关于线程概念及控制的相关内容，这篇博客主要是关于实现一个线程库的封装，完成对线程的创建、管理和销毁的基本功能

在书写封装库之前，我们先写对应的 Makefile 文件，方便我们后面的操作

代码语言：javascript代码运行次数：0运行复制

bin=codecc=g++src=$(wildcard *.cc)obj=$(src:.cc=.o)$(bin):$(obj)$(cc) -o $@ $^ -lpthread%.o:%.cc$(cc) -c $< -std=c++17.PHNOY:cleanclean:rm -f $(bin) $(obj)

1. 基本框架 ?

先写一个大概框架来实现我们的大概功能，如下：

代码语言：javascript代码运行次数：0运行复制

#ifndef _THREAD_HPP__#define _THREAD_HPP__#include #include #include #include #include #include namespace ThreadModule{    // using 关键字用于定义类型别名。这里，func_t 是你为某个类型起的别名    // 以后可以用 func_t 来代替原始类型 std::function    using func_t = std::function;    static int number = 1; // 记录线程数量    enum class TSTATUS  // 枚举：表示线程状态    {        NEW,        RUNNING,        STOP    };    class Thread    {    public:        Thread(func_t func)         {}        bool Start() // 开始        {}        bool Stop() // 终止        {}        bool Join() // 等待        {}        void Detach() // 分离        {}        ~Thread()        {}    private:    };}#endif

提前说一下，后面的代码，我就直接写 class Thread 中的内容了，关于头文件什么的为了节省篇幅，就省略了

代码剖析：

代码语言：javascript代码运行次数：0运行复制

#ifndef THREAD_HPP_#define THREAD_HPP_#endif

这段代码是一个 头文件保护（Header Guard） 的常见写法，用于防止头文件被多次包含（#include）的问题头文件保护中的宏名（如 _THREAD_HPP__）通常是根据文件名来命名的，通常使用大写字母和下划线（以避免与程序中的其他符号冲突）。宏名的选择可以使用文件名的某种形式，比如 _THREAD_HPP__ 对应的是 Thread.hpp 文件，或者使用其他自定义的宏名称 如果 _THREAD_HPP__ 没有被定义过，则执行 #define _THREAD_HPP__ 和随后的代码。 如果 _THREAD_HPP__ 已经被定义过，代码中对应的内容将不会再次执行，防止重复定义。

② #define _THREAD_HPP__ 这行代码会定义一个名为 _THREAD_HPP__ 的宏。定义这个宏后，后续的 #ifndef _THREAD_HPP__ 检查就会失败，代码就不会重复包含头文件的内容。 ③ #endif #endif 用来结束 #ifndef 或 #if 语句的条件块。它告诉编译器在这里结束这个条件的作用域 ④ 作用 这种头文件保护机制的作用是：

防止头文件被多次包含。在一个文件中，可能会有多个地方引用同一个头文件，而如果没有头文件保护机制，编译器在每次处理头文件时就会把其内容多次包含进来，导致重复定义的问题（如函数、变量或类的重复声明）。通过使用头文件保护，可以确保每个头文件的内容只会被包含一次

接下来我们开始写对应的成员变量，如下：

代码语言：javascript代码运行次数：0运行复制

private:    std::string _name;  // 线程名字    pthread_t _tid;     // 线程 id    pid_t _pid;         // 进程 id，判断线程属于哪个线程    bool _joinable;     // 是否是分离的，默认不是    func_t _func;       // 可以用来存储任何符合 void() 签名的可调用对象（如函数、Lambda 表达式）};

2. 构造函数实现 ?

然后对其构造函数，进行实现，如下：

代码语言：javascript代码运行次数：0运行复制

Thread(func_t func) : _func(func), _status(TSTATUS::NEW), _joinable(true){    _name = "Thread-" + std::to_string(number++);    _pid = getpid();}

分析：

func_t func 参数： 这个参数用于初始化该线程对象时传递给线程的任务（即线程将执行的代码）_func(func), _status(TSTATUS::NEW), _joinable(true) 初始化列表 _func(func): 将传入的 func 参数赋值给类的成员变量 _func，这意味着线程将在其生命周期内执行这个 func。_status(TSTATUS::NEW): 将线程的状态 _status 设置为 TSTATUS::NEW，表示线程刚创建，尚未开始执行。_joinable(true): 将 _joinable 设置为 true，表示该线程是可连接的（可以调用 join() 方法来等待线程结束）。通常线程在创建时默认是可连接的，除非设置为不可连接。该构造函数的目的是初始化一个 Thread 对象，并将线程的任务、状态、名称和进程 ID 设置为默认值。它支持通过传入一个 func_t 类型的可调用对象来指定线程的执行内容。使用静态变量 number 来确保每个线程都有一个唯一的名称，并通过 getpid() 获取当前进程的 ID 以便跟踪线程所属的进程。3. start 方法实现 ?代码语言：javascript代码运行次数：0运行复制

private:    // 成员方法！    static void* Routine(void* args) // 注意：这里是 static    {        Thread* t = static_cast(args);        t->_status = TSTATUS::RUNNING;        t->_func(); // 让线程在类内直接执行传入的方法        return nullptr;    }public:    bool Start()    {        if (_status != TSTATUS::RUNNING) // 防止线程被重复启动        {            int n = ::pthread_create(&_tid, nullptr, Routine, this); // 线程一旦创建            if (n != 0)                return false;            return true;        }        return false;    }

为什么 void *Rountine 前面用到了 static，明明 pthread_create 需要的就是void *

? 其中，start_routine 参数是一个函数指针，要求该函数的签名是：void* (*start_routine)(void*)，即它必须是一个接受 void* 参数并返回 void* 的函数。这意味着，pthread_create 需要一个普通的全局函数或者静态成员函数

但是不加 static 又会出问题，为什么呢？

原因：在 C++ 中，成员函数需要一个对象实例来调用，因此它隐式地包含一个 this 指针，用于指向该类的实例。而 pthread_create 不知道如何传递类实例，因此不能直接使用非静态成员函数作为 start_routine 参数。 静态成员函数：静态成员函数不依赖于类的实例，它不需要 this 指针。因此，静态成员函数的签名可以直接匹配 pthread_create 所要求的签名：void* (*start_routine)(void*)。 非静态成员函数：非静态成员函数需要一个对象实例的 this 指针，而 pthread_create 无法提供这个指针。即使你传递了一个类实例作为参数，它仍然无法解析 this 指针，因此不能直接作为 pthread_create 的回调函数。 两种解决办法： ① 把 Rountine 写到类外，但是不支持这样做，因为我们就是要做封装② 就是加一个 static 来去掉 this 指针

因此：

pthread_create 需要一个全局函数或静态成员函数，因为它无法处理类实例和 this 指针。static 关键字使得成员函数不依赖于实例，因此可以作为回调传递给 pthread_create4. Stop 和 Join 方法实现 ?代码语言：javascript代码运行次数：0运行复制

private:    void EnableDetach() { _joinable = false; }public:    bool Stop()    {        if (_status == TSTATUS::RUNNING)        {            int n = ::pthread_cancel(_tid); // 让线程自己退            if (n != 0)                return false;            _status = TSTATUS::STOP; // 取消成功之后，线程状态改变            return true;        }        return false;    }    bool Join() // bool 类型判断是否 Join 失败    {        if (_joinable) // 判断是否允许 等待，默认是 true 的        {            int n = ::pthread_join(_tid, nullptr); // 线程进行等待            if (n != 0)                return false;            _status = TSTATUS::STOP; //等待成功之后，线程状态改变            return true;        }        return false;    }    void Detach() // 让线程进行分离    {        EnableDetach(); // 开启线程的分离，改变 Joinable 的值        pthread_detach(_tid);    }    bool IsJoinable() { return _joinable; } // 判断是否被分离

上面的代码实现了对线程的管理功能，主要核心是： pthread

启动线程并确保线程不会被重复启动（通过 _status 状态判断）。允许线程取消（Stop）、等待线程结束（Join）或分离线程（Detach）。提供 IsJoinable() 来检查线程是否可以被连接（join）5. 测试接口和代码 ?代码语言：javascript代码运行次数：0运行复制

// 测试接口std::string Name() {return _name;} 

我们再编写一个 Main.cc 文件来对上面进行测试

代码语言：javascript代码运行次数：0运行复制

#include "Thread.hpp"#include #include int main(){    ThreadModule::Thread t([](){        while(true)        {            std::cout << "Hello world" << std::endl;            sleep(1);        }    });    t.Start();    std::cout << t.Name() << " is running" << std::endl;    sleep(5);    t.Stop();    std::cout << "Stop thread : " << t.Name() << std::endl;    sleep(1);        t.Join();    std::cout << "Join thread : " << t.Name() << std::endl;    return 0;}

代码运行情况如下：

后台线程查看如下：

代码语言：javascript代码运行次数：0运行复制

while :; do ps -aL|grep code; sleep 1; echo "-----------"; done

此时，我们就有新线程和主线程了，代码也基本实现成功了

上面我们的测试是创建了单个线程，那么我们如果要创建多线程呢？

代码语言：javascript代码运行次数：0运行复制

#include "Thread.hpp"#include #include // 如果要创建多线程呢 ？ #define NUM 5using thread_ptr_t = std::shared_ptr;int main(){    // 先描述再组织    std::unordered_map  threads;    // 如果我要创建多线程呢?    for(int i = 0; i < NUM; i++)    {        thread_ptr_t t = std::make_shared([]() { // 注意 ： make_shared 是 C++17 的            while(true)            {                std::cout << "Hello world" << std::endl;                sleep(1);            }        });        threads[t->Name()] = t;    }    for(auto &thread:threads)    {        thread.second->Start();    }    for(auto &thread:threads)    {        thread.second->Join();    }    return 0;}

结果如下：

注意：这里我们用到了 shared_ptr 来管理内存

a. 自动内存管理

使用 std::shared_ptr 的一个主要好处是它提供了自动内存管理。std::shared_ptr 是一种智能指针，能够确保其管理的对象在没有任何 shared_ptr 指向它时自动释放资源，这样就不需要显式地调用 delete 来释放内存。它基于引用计数机制，多个 shared_ptr 可以共同管理同一个对象，当最后一个指向该对象的 shared_ptr 被销毁时，资源会自动释放。这里每个线程对象通过 std::shared_ptr 来管理，确保了线程对象的生命周期和内存管理不会出错。

b. 多线程共享对象

由于每个线程的 thread_ptr_t 是 std::shared_ptr 类型，它使得多个线程能够共享对 ThreadModule::Thread 对象的所有权。如果你直接使用裸指针或 std::unique_ptr，则无法保证线程之间对对象的正确共享，特别是在涉及线程管理的复杂场景时例如，如果每个线程使用 std::shared_ptr 来引用同一个线程对象，并且一个线程在运行时被多个线程访问，shared_ptr 会保证对象在所有线程之间共享时依然能正确管理内存。

c. 避免线程结束时的对象销毁问题

在多线程环境中，如果你直接使用裸指针（比如 ThreadModule::Thread*），可能会遇到对象提前销毁的问题。假设你在 main 函数中创建了线程对象，并在线程启动后返回，那么线程对象在 main 函数结束时可能会被销毁，从而导致访问已经被销毁的对象，发生未定义行为std::shared_ptr 通过引用计数机制避免了这个问题，因为它能确保在所有 shared_ptr 被销毁之前，线程对象不会被销毁。这样，即使 main 函数中的某些线程对象超出了作用域，只要线程仍在运行，shared_ptr 会保持线程对象的生命周期，直到所有线程执行完毕并且不再需要该对象时，才会销毁该对象。

d. 线程对象的生命周期与线程管理

线程的生命周期通常是动态的，尤其是在多线程应用程序中。使用 std::shared_ptr 可以方便地控制线程对象的生命周期。例如，你可以把线程对象放到容器中（如 std::unordered_map），容器在处理线程时不需要担心对象的销毁问题。当所有线程结束并且没有其他 shared_ptr 指向该线程对象时，shared_ptr 会自动释放内存。6. 改进 ?

? 如果我们要对代码进程传参，做出如下修改即可

代码语言：javascript代码运行次数：0运行复制

namespace ThreadModule{    template     class Thread    {        using func_t = std::function;    private:        // 成员方法！        static void *Routine(void *args)        {            Thread *t = static_cast *>(args);            t->_status = TSTATUS::RUNNING;            t->_func(t->_data);            return nullptr;        }        void EnableDetach() { _joinable = false; }    public:        Thread(func_t func, T data) : _func(func), _data(data), _status(TSTATUS::NEW), _joinable(true)        {            _name = "Thread-" + std::to_string(number++);            _pid = getpid();        }    private:        // ...        T _data;    };}

修改后代码与修改前代码比较如下：

原始代码：没有模板类型，Thread 类只适用于没有类型参数的线程函数。线程函数的逻辑无法灵活地接收不同类型的数据。修改后的代码：Thread 类被模板化，允许线程类接受任意类型的参数 T。通过模板类型参数 T，你可以创建一个接受任意类型数据的线程。例如，传递一个 int 类型的数据，或者一个 std::string 类型的数据等。模板的使用使得这个类更具通用性和灵活性，可以支持更多样化的应用场景。

线程函数支持参数传递：

原始代码：线程的回调函数是一个没有参数的 lambda 表达式，无法直接传递任何参数。修改后的代码：线程函数通过 std::function 类型的 func_t 成员来定义，这使得回调函数可以接收类型为 T 的参数。因此，每个线程可以根据需要处理不同类型的数据，增强了代码的灵活性和通用性。

值得注意的是：为什么 using 定义类型别名要放到类里面？

func_t 是与模板类 Thread 紧密相关的类型别名，它表示线程执行函数的类型。把 using 语句放在类内部，可以确保 func_t 的类型在类内部是有效的。这样，类的实例可以直接使用 func_t 来定义线程回调函数的类型。

依赖模板参数 T：

func_t 是一个依赖于模板参数 T 的类型。把它放在类内部可以确保每个 Thread 实例有自己的 func_t 类型定义，而这个类型是与实例化时提供的 T 类型密切相关的。如果把func_t 放到类外部，编译器就无法知道 T 的具体类型，因此无法正确生成类型别名。

封装与局部性：

将 func_t 定义在类内部，保持了类内部的一致性和封装性。每个类实例都可以通过该类型别名来引用线程回调函数类型，避免了外部暴露太多实现细节。

与类成员的关系：

func_t 是线程函数类型的定义，它与类的成员函数、数据成员是紧密结合的。放在类内便于与类的其他成员进行组合和配合。类外部定义类型别名虽然也能使用，但会打破类的封装，增加不必要的复杂性。

代码测试如下：

代码语言：javascript代码运行次数：0运行复制

#include "Thread.hpp"#include #include #define NUM 5class threadData {public:    int max;    int start;};void Count(threadData td){    for(int i = td.start; i < td.max; i++){        std::cout << "i == " << i << std::endl;        sleep(1);    }}int main(){    //ThreadModule::Thread t(Count, 10);        threadData td;    td.max = 60, td.start = 50;    ThreadModule::Thread t(Count, td);    t.Start();    t.Join();    return 0;}

7. 完整代码 ?

1 号版本（这个也是我们后面经常会用到的）

代码语言：javascript代码运行次数：0运行复制

#ifndef _THREAD_HPP__#define _THREAD_HPP__#include #include #include #include #include #include // v1namespace ThreadModule{    using func_t = std::function;    static int number = 1;    enum class TSTATUS    {        NEW,        RUNNING,        STOP    };    class Thread    {    private:        // 成员方法！        static void *Routine(void *args) // 注意： 这里是 static        {            Thread *t = static_cast(args);            t->_status = TSTATUS::RUNNING;            t->_func(); // 让线程在类内直接执行传入的方法            return nullptr;        }        void EnableDetach() { _joinable = false; }            public:        Thread(func_t func) : _func(func), _status(TSTATUS::NEW), _joinable(true)        {            _name = "Thread-" + std::to_string(number++);            _pid = getpid();        }        bool Start()        {            if (_status != TSTATUS::RUNNING)            {                int n = ::pthread_create(&_tid, nullptr, Routine, this); // TODO                if (n != 0)                    return false;                return true;            }            return false;        }        bool Stop()        {            if (_status == TSTATUS::RUNNING)            {                int n = ::pthread_cancel(_tid); // 让线程自己退                if (n != 0)                    return false;                _status = TSTATUS::STOP; // 取消成功之后，线程状态改变                return true;            }            return false;        }        bool Join() // bool 类型判断是否 Join 失败        {            if (_joinable) // 判断是否允许 等待，默认是 true 的            {                int n = ::pthread_join(_tid, nullptr); // 线程进行等待                if (n != 0)                    return false;                _status = TSTATUS::STOP; //等待成功之后，线程状态改变                return true;            }            return false;        }        void Detach() // 让线程进行分离        {            EnableDetach(); // 开启线程的分离，改变 Joinable 的值            pthread_detach(_tid);        }        bool IsJoinable() { return _joinable; } // 判断是否被分离                // 测试接口        std::string Name() {return _name;}         ~Thread()        {        }    private:        std::string _name;  // 线程名字        pthread_t _tid;     // 线程 id        pid_t _pid;         // 进程 id，判断线程属于哪个线程        bool _joinable;     // 是否是分离的，默认不是        func_t _func;        TSTATUS _status;    };}#endif

2 号版本

代码语言：javascript代码运行次数：0运行复制

#ifndef _THREAD_HPP__#define _THREAD_HPP__#include #include #include #include #include #include // v2namespace ThreadModule{    static int number = 1;    enum class TSTATUS    {        NEW,        RUNNING,        STOP    };    template     class Thread    {        using func_t = std::function;    private:        // 成员方法！        static void *Routine(void *args)        {            Thread *t = static_cast *>(args);            t->_status = TSTATUS::RUNNING;            t->_func(t->_data);            return nullptr;        }        void EnableDetach() { _joinable = false; }    public:        Thread(func_t func, T data) : _func(func), _data(data), _status(TSTATUS::NEW), _joinable(true)        {            _name = "Thread-" + std::to_string(number++);            _pid = getpid();        }        bool Start()        {            if (_status != TSTATUS::RUNNING)            {                int n = ::pthread_create(&_tid, nullptr, Routine, this); // TODO                if (n != 0)                    return false;                return true;            }            return false;        }        bool Stop()        {            if (_status == TSTATUS::RUNNING)            {                int n = ::pthread_cancel(_tid);                if (n != 0)                    return false;                _status = TSTATUS::STOP;                return true;            }            return false;        }        bool Join()        {            if (_joinable)            {                int n = ::pthread_join(_tid, nullptr);                if (n != 0)                    return false;                _status = TSTATUS::STOP;                return true;            }            return false;        }        void Detach()        {            EnableDetach();            pthread_detach(_tid);        }        bool IsJoinable() { return _joinable; }        std::string Name() { return _name; }        ~Thread()        {        }    private:        std::string _name;        pthread_t _tid;        pid_t _pid;        bool _joinable; // 是否是分离的，默认不是        func_t _func;        TSTATUS _status;        T _data;    };}#endif

---

8. 共勉 ?