0
0

【Linux】：线程库简单封装

📃个人主页：island1314 ****************************************************************​***​​***

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

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

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

在书写封装库之前，我们先写对应的 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 <iostream>
#include <string>
#include <pthread.h>
#include <functional>
#include <sys/types.h>
#include <unistd.h>

namespace ThreadModule
{
    // using 关键字用于定义类型别名。这里，func_t 是你为某个类型起的别名
    // 以后可以用 func_t 来代替原始类型 std::function<void()>
    using func_t = std::function<void()>;
    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<Thread*>(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 <memory>
#include <unordered_map>

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 <memory>
#include <unordered_map>

// 如果要创建多线程呢 ？ 
#define NUM 5
using thread_ptr_t = std::shared_ptr<ThreadModule::Thread>;

int main()
{
    // 先描述再组织
    std::unordered_map <std::string, thread_ptr_t> threads;
    // 如果我要创建多线程呢?
    for(int i = 0; i < NUM; i++)
    {
        thread_ptr_t t = std::make_shared<ThreadModule::Thread>([]() { // 注意 ： 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 <typename T>
    class Thread
    {
        using func_t = std::function<void(T)>;
    private:
        // 成员方法！
        static void *Routine(void *args)
        {
            Thread<T> *t = static_cast<Thread<T> *>(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 <typename T>）：

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

线程函数支持参数传递：

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

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

类的作用域：

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

依赖模板参数 T：

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

封装与局部性：

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

与类成员的关系：

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

代码测试如下：

#include "Thread.hpp"
#include <memory>
#include <unordered_map>

#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<int> t(Count, 10);
    
    threadData td;
    td.max = 60, td.start = 50;
    ThreadModule::Thread<threadData> t(Count, td);
    t.Start();

    t.Join();
    return 0;
}

7. 完整代码 📖

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

#ifndef _THREAD_HPP__
#define _THREAD_HPP__

#include <iostream>
#include <string>
#include <pthread.h>
#include <functional>
#include <sys/types.h>
#include <unistd.h>

// v1
namespace ThreadModule
{
    using func_t = std::function<void()>;
    static int number = 1;
    enum class TSTATUS
    {
        NEW,
        RUNNING,
        STOP
    };

    class Thread
    {
    private:
        // 成员方法！
        static void *Routine(void *args) // 注意： 这里是 static
        {
            Thread *t = static_cast<Thread *>(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 <iostream>
#include <string>
#include <pthread.h>
#include <functional>
#include <sys/types.h>
#include <unistd.h>

// v2
namespace ThreadModule
{
    static int number = 1;
    enum class TSTATUS
    {
        NEW,
        RUNNING,
        STOP
    };

    template <typename T>
    class Thread
    {
        using func_t = std::function<void(T)>;
    private:
        // 成员方法！
        static void *Routine(void *args)
        {
            Thread<T> *t = static_cast<Thread<T> *>(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. 勉励

【★,°*:.☆(￣▽￣)/$:*.°★ 】那么本篇到此就结束啦，如果有不懂 和 发现问题的小伙伴可以在评论区说出来哦，同时我还会继续更新关于【Linux】的内容，请持续关注我 ！！**

标签： 学习 linux 运维
本文转载自: https://blog.csdn.net/island1314/article/details/143974090
版权归原作者 IsLand1314~ 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【Linux】：线程库简单封装”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航