【Linux】：线程库 Thread.hpp 简单封装

2025-05-14 21:00:56 0 阅读

📃个人主页：island1314 

🔥个人专栏：Linux—登神长阶

⛺️ 欢迎关注：👍点赞 👂🏽留言 😍收藏 💞 💞 💞

1. 基本框架 🐋

2. 构造函数实现 🦮

3. start 方法实现 🐲

4. Stop 和 Join 方法实现 🐇

5. 测试接口和代码 🦌

6. 改进 🎈

7. 完整代码 📖

8. 勉励

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

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

bin=code
cc=g++
src=$(wildcard *.cc)
obj=$(src:.cc=.o)

$(bin):$(obj)
	$(cc) -o $@ $^ -lpthread
%.o:%.cc
	$(cc) -c $< -std=c++17

.PHNOY:clean
clean:
	rm -f $(bin) $(obj)

1. 基本框架 🐋

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

#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 中的内容了，关于头文件什么的为了节省篇幅，就省略了

代码剖析：

#ifndef THREAD_HPP_
#define THREAD_HPP_
#endif

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

① #ifndef _THREAD_HPP__

#ifndef 是 "if not defined" 的缩写。它的作用是检查一个宏是否没有被定义过。在这个例子中，它检查宏 _THREAD_HPP__ 是否已经被定义过

如果 _THREAD_HPP__ 没有被定义过，则执行 #define _THREAD_HPP__ 和随后的代码。

如果 _THREAD_HPP__ 已经被定义过，代码中对应的内容将不会再次执行，防止重复定义。

② #define _THREAD_HPP__

这行代码会定义一个名为 _THREAD_HPP__ 的宏。定义这个宏后，后续的 #ifndef _THREAD_HPP__ 检查就会失败，代码就不会重复包含头文件的内容。

③ #endif

#endif 用来结束 #ifndef 或 #if 语句的条件块。它告诉编译器在这里结束这个条件的作用域

④ 作用

这种头文件保护机制的作用是：

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

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

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

2. 构造函数实现 🦮

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

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 方法实现 🐲

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_create

4. Stop 和 Join 方法实现 🐇

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. 测试接口和代码 🦌

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

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

#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;
}

代码运行情况如下：

后台线程查看如下：

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

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

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

#include "Thread.hpp"
#include 
#include 

// 如果要创建多线程呢 ？ 
#define NUM 5
using 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. 改进 🎈

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

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;
    };
}

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

模板化（template ）：

原始代码：没有模板类型，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 是线程函数类型的定义，它与类的成员函数、数据成员是紧密结合的。放在类内便于与类的其他成员进行组合和配合。类外部定义类型别名虽然也能使用，但会打破类的封装，增加不必要的复杂性。

代码测试如下：

#include "Thread.hpp"
#include 
#include 

#define NUM 5

class 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 号版本（这个也是我们后面经常会用到的）

#ifndef _THREAD_HPP__
#define _THREAD_HPP__

#include 
#include 
#include 
#include 
#include 
#include 


// v1
namespace 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 号版本

#ifndef _THREAD_HPP__
#define _THREAD_HPP__

#include 
#include 
#include 
#include 
#include 
#include 


// v2
namespace 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