Linux系统编程——线程池

最新推荐文章于 2024-09-12 20:58:18 发布
最新推荐文章于 2024-09-12 20:58:18 发布
阅读量953 收藏 13
点赞数 24
分类专栏： linux系统编程 文章标签： linux 服务器 C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaqq800520/article/details/140724453
版权

目录

一，池化技术

二，线程池概念

三，线程池实现

3.1 线程封装

3.2 预备头文件实现

3.3 线程池类的简单实现

3.4 主函数实现

3.5 效果展示

一，池化技术

池化技术是计算机编程领域非常常用的一种技术，该技术可以在编程过程中提前准备一些资源，在需要时可以重复使用这些预先准备的资源

最直观的两个例子：

  1. 我们要申请堆空间，要使用malloc去申请。我们都知道申请内存是有代价的，在频繁malloc的情况下，执行时间会大幅度上升，造成整体效率降低。
  2. malloc使用完后，还要free掉避免内存泄漏。而释放和申请一样，都是有代价的。

在系统化的开发过程中，我们经常会用到池化技术：把一些资源预先申请并分配好，组织到对象池中，之后的业务使用资源从对象池中获取，使用完后放回到对象池中。即对象池对资源（线程、连接和内存）进行管理，这样做带来几个明显的好处：

  1. 资源能重复利用：减少了资源分配和释放过程中的系统消耗。比如上面的malloc和free，减少申请次数和释放次数。再比如，在IO密集型的服务器上，并发处理过程中的子线程或子进程的创建和销毁过程，带来的系统开销将是难以接受的。所以在业务实现上，通常把一些资源预先分配好，如线程池，数据库连接池，Redis连接池，HTTP连接池等，来减少系统消耗，提升系统性能。
  2. 可以对资源的整体使用做限制：相关资源预分配且只在预分配是生成，后续不再动态添加，从而限制了整个系统对资源的使用上限。类似一个令牌桶的功能。
  3. 池化技术分配对象池：通常会集中分配，这样有效避免了碎片化的问题。

二，线程池概念

线程池是一种线程使用模式，池化技术的一种具体作用和优点前面也符合池化技术的用途和优点

  1. 线程池避免了系统在处理短时间任务时反复创建和销毁线程时要付出的代价
  2. 线程池保证了内核资源充分利用，也能防止过度调度

线程池常见的应用场景如下： 

  1. 任务时间短，但是有很多个，需要大量线程来完成任务
  2. 需要较为苛刻的性能要求，比如要求服务器能迅速响应客户需求
  3. 接受突发性的大量请求，但不至于使服务器立马创建大量线程的应用

三，线程池实现

3.1 线程封装

 我们可以把线程搞成一个类，并一齐封装好线程的常用接口，能在线程池代码中方便使用，并且在以后的网络套接字代码编程也可以方便使用 

#pragma once
#include <iostream>
#include <string>
#include <functional>
#include <cstdio>

// typedef std::function<void* (void*)> fun_t; // 定义一个函数对象，这个函数返回值是void，参数类型是void*
// 但是要考虑兼容性问题，操作系统的接口是C的，所以用函数对象的话下面的创建线程可能无法识别函数对象
typedef void *(*fun_t)(void *); // 这是一个参数为void*，返回值为void*的一个函数指针，该指针类型命名为fun_t

class ThreadData
{
public:
    void *_args;
    std::string _name;
};

class Thread
{
public:
    Thread(int num, fun_t callback, void *args)
        : _func(callback)
    {
        char nameBuffer[64];
        snprintf(nameBuffer, sizeof nameBuffer, "Thread-%d", num); // 这个函数表示往特定数组写字符串，第一个表示要写的对象，第二个表示要写的数量或大小，第三个表示写的内容
        _name = nameBuffer;

        _tdata._args = args;
        _tdata._name = _name; // 方便后面使用线程名字
    }

    void start()
    {
        pthread_create(&_tid, nullptr, _func, (void *)&_tdata);
    }
    void join()
    {
        pthread_join(_tid, nullptr);
    }
    std::string GetName()
    {
        return _name;
    }
    ~Thread()
    {
    }

private:
    std::string _name;
    pthread_t _tid;
    ThreadData _tdata;
    fun_t _func; // 表示线程要执行的函数
};

3.2 预备头文件实现

makefile：

thread_pool:testMain.cc
	g++ -o $@ $^ -std=c++11 -lpthread #-DDEBUG_SHOW
.PHONY:clean
clean:
	rm -f thread_pool

 RAII加锁方式，lockGuard.hpp：

#pragma once

#include <iostream>
#include <pthread.h>

class Mutex
{
public:
    Mutex(pthread_mutex_t *mtx) : pmtx_(mtx)
    {
    }
    void lock()
    {
        // std::cout << "要进行加锁" << std::endl;
        pthread_mutex_lock(pmtx_);
    }
    void unlock()
    {
        // std::cout << "要进行解锁" << std::endl;
        pthread_mutex_unlock(pmtx_);
    }
    ~Mutex()
    {
    }

private:
    pthread_mutex_t *pmtx_;
};

// RAII风格的加锁方式
class lockGuard
{
public:
    lockGuard(pthread_mutex_t *mtx) : mtx_(mtx)
    {
        mtx_.lock();
    }
    ~lockGuard()
    {
        mtx_.unlock();
    }

private:
    Mutex mtx_;
};

任务头文件，Task.hpp：

#include <iostream>
#include <string>
#include <functional>
#include "log.hpp"

typedef std::function<int(int, int)> func_t;

class Task
{
public:
    Task() {}
    Task(int x, int y, func_t func) : _x(x), _y(y), _func(func)
    {
    }
    void operator()(const std::string &name)
    {
        // 不规范
        //  std::cout << "线程 " << name << " 处理完成, 结果是: " << x_ << "+" << y_ << "=" << func_(x_, y_) << std::endl;
        logMessage(WARNING, "%s处理完成: %d+%d=%d | %s | %d",
                   name.c_str(), _x, _y, _func(_x, _y), __FILE__, __LINE__); // 预处理符，方便定位文件名和位置
    }

public:
    int _x;
    int _y;
    // int type;
    func_t _func;
};

日志头文件，复杂打印程序运作信息到屏幕上或者将信息写进日志文件

log.hpp： 

#pragma once

#include <iostream>
#include <cstdio>
#include <cstdarg>
#include <ctime>
#include <string>

// 日志是有日志级别的
#define DEBUG 0
#define NORMAL 1
#define WARNING 2
#define ERROR 3
#define FATAL 4

const char *gLevelMap[] = {
    "DEBUG",
    "NORMAL",
    "WARNING",
    "ERROR",
    "FATAL"};

#define LOGFILE "./threadpool.log"

// 完整的日志功能至少包含：日志等级，时间，日志内容，并且支持用户自定义
void logMessage(int level, const char *format, ...)
{
#ifndef DEBUG_SHOW // 在makefile中加-DDEBUG_SHOW表示我想调试，就打印调试信息，如果我们#注释掉宏定义，再次make后就不打印调试信息了
    if (level == DEBUG)
        return;
#endif
    // 提取可变参数 -- 麻烦
    //  va_list ap; //是一个char*类型
    //  va_start(ap, format); //用一个参数来初始化它
    //  while(true)
    //  int x = va_arg(ap, int);  //用ap制作提取一个整数，没有int就返回NULL
    //  va_end(ap); //类似ap=nullptr

    char stdBuffer[1024];             // 日志的标准部分
    time_t timestamp = time(nullptr); // 获取时间戳
    // struct tm *localtime = localtime(&timestamp);
    // localtime->tm_hour;
    snprintf(stdBuffer, sizeof stdBuffer, "[%s] [%ld] ", gLevelMap[level], timestamp); // 把日志的标准部分搞到字符数组里

    char logBuffer[1024];
    va_list args;
    va_start(args, format); // 可变参数列表的起始地址
    // vprintf(format, args); //格式化打印可变参数列表到屏幕
    vsnprintf(logBuffer, sizeof logBuffer, format, args); // 将参数列表搞到logBuffer中
    va_end(args);

    // 把日志信息往文件里写入
    // FILE *fp = fopen(LOGFILE, "a");
    printf("%s%s\n", stdBuffer, logBuffer);
    // fprintf(fp, "%s%s\n", stdBuffer, logBuffer);
    // fclose(fp);
}

3.3 线程池类的简单实现

线程池主要包含两个数据结构：一个数组，负责存放线程类的指针；一个队列，负责存放任务。

  • 线程池中的多个线程只负责处理执行任务，并不参与制作任务，因为到后面任务从网络中来
  • 线程池只对外提供Push接口，用于外部线程将任务扔进队列里

代码如下，threadPool.hpp：

 

#pragma once

#include <vector>
#include <queue>
#include <unistd.h>

#include "thread.hpp"
#include "lockGuard.hpp"
#include "log.hpp"

const int g_thread_num = 3; // 表示默认创建线程个数

// 线程池本质是一个生产消费模型
template <class T>
class ThreadPool
{
public:
    pthread_mutex_t *getMutex() // 获取锁的地址
    {
        return &_lock;
    }
    bool isEmpty() // 判断队列是否为空
    {
        return task_queue_.empty();
    }

    void waitCond()
    {
        pthread_cond_wait(&_cond, &_lock); // 等待的时候释放锁，唤醒时再申请锁
    }

    T getTask()
    {
        T t = task_queue_.front();
        task_queue_.pop();
        return t;
    }

public:
    ThreadPool(int thread_num = g_thread_num)
        : _num(thread_num)
    {
        pthread_mutex_init(&_lock, nullptr); // 初始化锁
        pthread_cond_init(&_cond, nullptr);  // 初始化条件变量
        for (int i = 1; i <= _num; i++)
        {
            _threads.push_back(new Thread(i, routine, this)); // 传this指针，让回调方法能够访问类
        }
    }

    void run() // 线程池启动
    {
        for (auto &iter : _threads)
        {
            iter->start(); // 执行thread_create函数，创建线程，创建的数量由数组大小来定，而数组大小在构造函数定义好了，
            // std::cout << iter->GetName() << "启动成功" << std::endl;
            logMessage(NORMAL, "%s%s", iter->GetName().c_str(), "启动成功");
        }
    }
    // 取任务
    // 如果定义在类内，会有隐藏this指针从而影响使用，所以加上static
    // 如果一个类内部成员用static，那么它只能使用静态成员再调用静态方法，无法使用类内的成员属性和方法
    // 如果这个静态的routine是所谓的消费线程，那么要pop队列，但是编译时会报错，这就坑了
    // 所以为了能让routine拿到类内属性，我们再上面push_back的插入Thread对象时，可以把this指针传过来，通过函数来进行访问（与其让它拿到task_queue，不如让它拿
    static void *routine(void *args)
    {
        ThreadData *td = static_cast<ThreadData *>(args);            // 该操作形象点说就是改文件后缀，这里的后缀是args指针
        ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(td->_args); // 然后这一步相当于解压操作，拿到指针指向对象的线程池指针
        // 消费逻辑
        // 先加锁，while(task_queue_.empty()) wait(); 如果任务队列为空就等待
        // 不为空就获取任务，然后处理，处理完就解锁
        while (true)
        {
            T task;
            {
                lockGuard lockguard(tp->getMutex()); // 通过this指针调用getMutex获得锁的地址，实现加锁，保证该代码块是安全的代码块
                while (tp->isEmpty())
                    tp->waitCond(); // 判断队列是否为空，为空就等待
                // 读取任务
                task = tp->getTask(); // 任务队列是共享的，这句话就是将任务从共享，拿到自己的私有空间
            }
            task(td->_name); // 执行任务，task是队列里的数据，也就是Task类，改类重载了operator()，所以可以直接使用圆括号执行任务

            // 测试能否传入this指针
            // tp->show();
            // sleep(1);
        }
    }
    // 往队列里塞任务
    void pushTask(const T &task)
    {
        lockGuard lockguard(&_lock); // 只单纯加锁，加了任务后还应该要唤醒对应的消费线程来消费
        task_queue_.push(task);
        pthread_cond_signal(&_cond);
    }

    // 测试接口
    void joins()
    {
        for (auto &iter : _threads)
        {
            iter->join();
        }
    }
    // 测试构造函数是否可以传入this指针
    void show()
    {
        std::cout << "可以传入this，可以让静态方法的线程，访问到线程池内的方法" << std::endl;
    }

    ~ThreadPool()
    {
        for (auto &iter : _threads)
        {
            iter->join(); // 在释放前join下
            delete iter;
        }
        pthread_mutex_destroy(&_lock);
        pthread_cond_destroy(&_cond);
    }

private:
    std::vector<Thread *> _threads; // 这个数组存的是将来要创建的线程
    int _num;
    std::queue<T> task_queue_; // 别人发任务来放到队列里，然后派发给指定线程去执行，所以只要添加到队列里，就自动叫醒一个线程来处理
    pthread_mutex_t _lock;
    pthread_cond_t _cond;

    // 另一种方案：
    // 我们一开始定义两个队列queue1，queue2
    // 然后再定义两个制作std::queue<T> *p_queue,  *c_queue
    // 然后p_queue->queue1,  c_queue->queue2
    // 当生产一批任务后，我们放到queue1里，然后swap(p_queue, c)queue);
    // 然后消费者处理完毕后再swap(p_queue, c_queue);
    // 所以因为我们生产和消费用的是不同的队列，未来我们进行资源任务处理的时候，仅仅只需要交换制作，而且也只要把这个交换这一句加锁即可
};

①关于线程池里的互斥锁和条件变量

  1. 线程池中的任务队列会被多个执行流共同访问，因此需要加锁保护任务队列
  2. 队列里有任务线程才能拿任务，所以需要有条件变量，当队列为空时，线程就阻塞等待，当使用Push往队列放任务后，通知线程来执行
  3. 并且我们是把任务执行的语句放在解锁后的，因为当线程从任务队列拿到任务后，该任务就已经属于该线程了，与其它线程没有关系了，不需要保护了；并且如果是在加锁解锁中间执行的任务，那么一个线程只有执行完任务释放锁后其它线程才能申请到锁执行任务，就没有发挥线程“并行”的优势了 

②线程执行函数为什么要设置成静态 

  • 线程执行的函数为routine，该函数设置为静态
  • 因为线程接口的要求是参数为void*，返回值为void*的一个函数，而routine函数在类内实现，所以会默认带一个this指针，从而导致编译失败，所以要设置为静态，不让他默认带this指针
  • 但是由于routine没有this指针，导致它不能访问类内的成员属性和其它成员函数，所以我们在构造函数中创建线程时，将this指针作为参数传递给线程执行函数routine，这样routine就可以通过它的参数指针访问类内的属性了 

3.4 主函数实现

#include "threadPool.hpp"
#include "Task.hpp"
#include <iostream>
#include <sys/types.h>
#include <unistd.h>

int main()
{
    // logMessage(NORMAL, "%s %d %c %f \n", "这是一条日志信息", 1234, 'c', 3.14);
    srand((unsigned long)time(nullptr) ^ getpid());
    // 线程池启动
    ThreadPool<Task> *tp = new ThreadPool<Task>();
    tp->run();
    sleep(3);
    // 构建任务
    while (true)
    {
        // 生产任务的过程，制作任务的时候，要花时间
        int x = rand() % 100 + 1;
        usleep(7721);
        int y = rand() % 30 + 1;
        Task t(x, y, [](int x, int y) -> int
               { return x + y; });
        // std::cout << "任务制作完成" << x << " + " << y << " = ?" << std::endl;
        logMessage(DEBUG, "制作任务完成：%d+%d=?", x, y);

        // 推送任务到线程池中
        tp->pushTask(t);
        sleep(1);
    }
    return 0;
}

主函数代码很简单，首先创建线程池对象，然后while循环，创建任务对象，用lamdba表达式构建的加法函数初始化任务对象，然后将任务对象push进线程池的任务队列，然后线程池里面的线程自动执行任务代码 

3.5 效果展示

与你日常
关注
  • 24
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux系统：线程池
盒马的博客
06-16 1238
讲解Linux中的线程池，利用面向对象思想，基于C++语言，封装了线程的类，以及线程池
Linux--实现线程池（万字详解）
2301_76618602的博客
07-19 899
IT行业这么火, 涌入的人很多. 俗话说林子大了啥鸟都有. 大佬和菜鸡们两极分化的越来越严重. 为了让菜鸡们不太拖大佬的后腿, 于是大佬们针对一些经典的常见的场景, 给定了一些对应的解决方案, 这个就是 设计模式。
Linux网络编程——线程池
qq_37233070的博客
04-09 370
一、传统线程工作方式 传统线程工作方式: 接收消息 ==> 消息分类 ==> 线程创建 ==> 传递消息到子线程 ==> 线程分离 ==> 在子线程中执行任务 ==> 子线程任务结束 ==> 销毁子线程； 当面临大量消息频繁请求服务器的情况时，会频繁的创建与销毁线程，而这是一种奢侈的开销，特别对于嵌入式服务器来说更应保证内存资源的合理利用； 为了适当解决这一过程，催生出了线程池（threadpool）。 线程池允许一...
Linux网络编程——线程池架构
l1206715877的博客
06-30 386
线程池概念及用途 概念：实质就是一个装着线程的的容器，线程池一种多线程的处理方式，处理过程间任务添加到队列，然后创建线程后自动启动这些任务。 比喻：这有点像去街上借的共享充电宝，收集这些充电宝的盒子就是线程池，充电宝就是线程。每个人去拿共享充电宝，就相当于是充电宝接任务。从这个比喻可以知道，共享充电宝收集盒（线程池）里面要先有一些充电宝（已经创建好的线程）才行。 为什么要有线程池：节省资源，每次来一个客户端都要创建、销毁、运行，这会消耗大量资源（因为创建和销毁会占用时间）。如果提前创建好一堆线程
Linux网络编程——线程池模型
weixin_44832458的博客
05-16 217
Linux网络编程——线程池模型 文章目录Linux网络编程——线程池模型前言一、线程池主要函数说明二、代码实现 前言 线程池创建代码参考博客：https://blog.csdn.net/weixin_38956024/article/details/107892958 一、线程池主要函数说明 threadpool_t* threadpool_create(int min_thr_num, int max_thr_num, int queue_max_size) //创建一个线程池 //min_thr_
【Linux】线程——线程池、线程池的实现、线程安全的线程池、单例模式的概念、饿汉和懒汉模式、互斥锁、条件变量、信号量、自旋锁、读写锁
Crocodile1006的博客
07-18 1317
Linux线程、线程池、线程池介绍、线程池的实现、线程安全的线程池、单例模式的概念、饿汉和懒汉模式、常见锁使用汇总、互斥锁（Mutex）条件变量（Condition Variable）信号量（Semaphore）自旋锁（Spin Lock）读写锁（Read-Write Lock）
Linux操作系统——线程池（一）
weixin_53811859的博客
10-22 134
烂笔头不如好记性
Linux网络编程8——线程池模型
HuanBianCheng27的博客
11-07 355
多线程服务器，每次客户端发过来信息服务端就会创建一个线程，处理完了再销毁线程开销有点大。
Linux系统编程——多线程
m0_60697583的博客
04-23 794
在Linux系统编程中，多线程编程是一项重要的技能，它允许程序同时执行多个任务，提高了程序的并发性和效率。当涉及到在Linux上进行多线程编程时，可以使用POSIX线程库(pthread)。POSIX线程库提供了一组函数和数据结构，使得在多线程环境下创建、同步和管理线程变得更加容易。
Linux 网络编程——TCP编程示例代码
05-12
在Linux系统中，网络编程是开发跨平台应用和服务的关键技术之一。TCP（Transmission Control Protocol）是一种面向连接的、可靠的传输协议，广泛应用于互联网中的各种服务，如HTTP、FTP等。本篇文章将深入探讨Linux...
电子科技大学linux环境编程作业——李林——编写一个多队列线程池应用
03-26
编写一个多队列线程池应用 编写一个实现了整数加法运算的线程池 在这个应用中，有三种线程： 一个用户线程。用于向线程池（主控线程）提出加法计算请求 一个主控线程。用于接收用户线程发送的加法计算请求，并负载...
Java并发系列（13）——线程池的选择与参数设置
JinchaoLv的博客
11-22 840
接上一篇《Java并发系列（12）——ForkJoin框架源码解析》 文章目录9.5 线程池的选择与参数设置9.5.1 JDK 预定义的线程池9.5.1.1 Executors#newCachedThreadPool9.5.1.2 Executors#newFixedThreadPool9.5.1.3 Executors#newScheduledThreadPool9.5.1.4 Executors#newSingleThreadExecutor9.5.1.5 Executors#newSin
Linux 进程控制
2302_77289177的博客
09-08 1203
Linux 进程控制
【Linux】：信号与信号产生
最新发布
Yikefore的博客
09-12 610
信号的基本概念、对信号的理解、信号的多种产生方式以及核心转储的详细介绍！
高效诊断Linux性能问题
Tiger93的博客
09-08 512
诊断Linux性能问题
＜Linux＞ 基础IO
prodigy623的博客
09-06 1052
详解Linux基础IO：文件系统调用接口与C库文件函数的关系、重定向、数据缓冲区、文件系统、动静态库
Linux如何使用sed命令进行文本替换
yang295242361的博客
09-12 352
在Linux中，sed（Stream Editor）是一个用于处理文本流的命令行工具，它非常适合用于执行基本的文本转换。sed可以读取输入的文本文件，根据指定的指令对文本进行处理，并将结果输出到标准输出设备。
Linux系统编程书籍——献给IT从业者
本书《Linux系统编程》主要涵盖了Linux环境下进行系统级编程的相关知识，旨在帮助读者深入理解Linux系统的工作原理，并具备编写高效、可靠的系统级程序的能力。书中内容可能包括但不限于以下几个核心知识点： 1. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值