【lesson58】线程池

(unstoppable)

已于 2024-02-19 10:21:58 修改

阅读量230

点赞数 6

分类专栏： linux 文章标签：线程池 Linux C++ 线程控制

于 2024-02-19 10:19:30 首次发布

本文链接：https://blog.csdn.net/m0_67077469/article/details/136162868

版权

linux 专栏收录该内容

62 篇文章 2 订阅

订阅专栏

文章目录

线程池概念
线程池应用场景
编码

线程池概念

一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。

线程池应用场景

1.需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。但对于长时间的任务，比如一个Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。

2.对性能要求苛刻的应用，比如要求服务器迅速响应客户请求。

3.接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池情况下，将产生大量线程，虽然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限，出现错误。

编码

思路：
1.创建固定数量线程池，循环从任务队列中获取任务对象，
2.获取到任务对象后，执行任务对象中的任务接口

Log.hpp

首先我们要写的就是，日志因为日志是项目的必须品，有时候我们非常需要用日志来打印一些调试或者其它信息

#pragma once
#include "Common.h"

// 日志是有日志级别的
#define DEBUG    0//调试
#define NORMAL   1//正常
#define WARNING  2//警告
#define ERROR    3//错误，但不致命
#define FATAL    4//致命的级别

#define STANDARD_NUM 1024//标准部分
#define CUSTOM_NUM 1024//自定义部分

const char *gLevelMap[] = {
    "DEBUG",
    "NORMAL",
    "WARNING",
    "ERROR",
    "FATAL"};//日志级别字符串

//一个日志分为两部分：标准部分和自定义部分
//标准部分: 日志级别+日志时间戳
//自定义部分: 自己要输入的信息
void LogMessage(int level, const char *format, ...)
{
 #ifndef DEBUG_SHOW
    if(level== DEBUG) return;
#endif
    // 标准部分
    char standard_buffer[STANDARD_NUM];
    snprintf(standard_buffer, sizeof(standard_buffer), "[%s][%ld]", gLevelMap[level], time(nullptr));

    // 自定义部分
    char custom_buffer[CUSTOM_NUM];
    va_list args;
    va_start(args, format);
    vsnprintf(custom_buffer, sizeof(custom_buffer), format, args);
    va_end(args);
	
	//输出标准部分和自定义部分的信息
    printf("%s%s\n", standard_buffer, custom_buffer);
}

Thread.hpp

在实现线程池之前我们先封装线程以便于我们管理

#include "Common.h"
#include "Log.hpp"

//重命名 线程回调函数
typedef void *(*fun_t)(void *);

//定义线程数据对象，这些数据可以暴露给外界
class ThreadData
{
public:
    std::string _name;
    void *_args;
};

class Thread
{
public:
	//用传入的参数：初始化线程的名字，回调函数和args
    Thread(std::string name, fun_t routine, void *args)
    {
        _thread_data._name = name;
        _func = routine;
        _thread_data._args = args;
    }
	
	//启动线程，也就是开始创建线程
    void Start()
    {
        pthread_create(&_tid, nullptr, _func, (void*)&_thread_data);
        //std::cout <<  _thread_data._name << " create success" << std::endl;
        LogMessage(NORMAL,"%s creadte success",_thread_data._name.c_str());
    }
	
	//线程等待
    void Join()
    {
        pthread_join(_tid, nullptr);
        //std::cout <<  _thread_data._name << " join success" << std::endl;
        LogMessage(NORMAL,"%s join success",_thread_data._name.c_str());
    }
	
	//获取线程名
    std::string GetName()
    {
        return _thread_data._name;
    }

private:
    ThreadData _thread_data;//线程基础数据对象
    pthread_t _tid;//线程tid
    fun_t _func;//线程回调函数
};

之后便是线程池的实现

#include "Common.h"
#include "Thread.hpp"
#include "LockGuard.hpp"
#include "Cond.hpp"
#include "Log.hpp"

template <class T>
class ThreadPool
{
private:
	//判断任务队列是否为空
    bool Empty()
    {
        return _task_queue.empty();
    }
	
	//从任务队列里拿任务
    void PopTask(T *out)
    {
    	//RIAA风格的加锁解锁，当出现异常，不会造成死锁问题
        LockGuard lock(&_mtx);
        while (Empty())
        {
            _cond.Wait(&_mtx.GetMutex());
        }

        // std::cout << "hello" << std::endl;
        *out = _task_queue.front();
        _task_queue.pop();
    }
	
	//将构造函数设为私有的，以防外界构造函数
    ThreadPool(int thread_num = THREAD_POOOL_NUM)
        : _thhread_num(thread_num)
    {
    	//创建线程，并将线程放入任务队列中
        for (int i = 0; i < _thhread_num; i++)
        {
            std::string name = "thread ";
            name += std::to_string(i + 1);
            //这里传this指针是因为静态成员不能访问类内私有变量
            //而传this指针就可以解决这个问题
            _threads.push_back(new Thread(name, Rountine, this));
        }
    }

	//将拷贝构造也设为私有
    ThreadPool(const ThreadPool<T>&) = delete;
public:
	//给外界提供获取唯一对象的接口
    static ThreadPool<T>* GetIstance()
    {
        return &Thread_Pool_Instance;
    }

	//启动线程
    void Run()
    {
        for (auto &iter : _threads)
        {
            iter->Start();
            //std::cout << iter->GetName() << " start success" << std::endl;
            LogMessage(NORMAL,"%s start success",iter->GetName().c_str());
        }
    }
	
	//线程回调函数，这里设计成static是因为类内函数有隐藏的this指针
	//而线程的回台函数只能是void * (void *args)类型的
    static void *Rountine(void *args)
    {
		//因为thread实现的时候传的是ThreadData*类型的指针
		// pthread_create(&_tid, nullptr, _func, (void*)&_thread_data);
		//所以我们要把void* 转成 ThreadData *
        ThreadData *td = (ThreadData *)args;
        //而我们传的this又在ThreadData类的void *_args中，
        /*class ThreadData
		{
		public:
    	std::string _name;
    	void *_args;
		};*/
        //所以我们又要把void* 转成 ThreadPool<T> *
        ThreadPool<T> *tp = (ThreadPool<T> *)td->_args;
        while (true)
        {
            T task;
            {
            	//拿任务
                tp->PopTask(&task);
                //执行任务
                //std::cout << "Get a task: " << task._x << " + " << task._y << " = " << task() << std::endl;
                LogMessage(NORMAL,"Get a task: %d + %d = %d",task._x,task._y,task());
                sleep(1);
            }
        }
    }

    void PushTask(T &in)
    {
    	//RIAA风格加锁和解锁
        LockGuard lock(&_mtx);
        //向任务队列插入任务
        _task_queue.push(in);
        //唤醒线程来拿任务
        _cond.WakeUp();
    }
	
	//join等待线程
    ~ThreadPool()
    {
        for (auto &iter : _threads)
        {
            iter->Join();
        }
        //pthread_cond_destroy(&_cond);
    }

private:
    int _thhread_num;//线程个数
    std::vector<Thread *> _threads;//用数组存储线程，以便于管理
    std::queue<T> _task_queue;//任务队列

    Mutex _mtx;//自己封装的锁，可以自动初始化和销毁
    //pthread_cond_t _cond;
    Cond _cond;//自己封装的条件变量，可以自动初始化和销毁

    static ThreadPool<T> Thread_Pool_Instance;//把线程池设计成单例模式
};

template<class T>
ThreadPool<T> ThreadPool<T>::Thread_Pool_Instance;//初始化全局唯一类

我们实现的是饿汉模式的单例。

LockGuard.hpp

#pragma once
#include "Common.h"

//封装锁目的：使锁可以初始化黑销毁
class Mutex
{
public:
    Mutex()
    {
        pthread_mutex_init(&_mtx,nullptr);
    }

    pthread_mutex_t& GetMutex()
    {
        return _mtx;
    }

    ~Mutex()
    {
        pthread_mutex_destroy(&_mtx);
    }
private:
    pthread_mutex_t _mtx;
};

//封装加锁解锁目的：使锁可以自动的加锁和解锁
class LockGuard
{
public:
    LockGuard(Mutex* mtx)
    :_mtx(mtx)
    {
        pthread_mutex_lock(&_mtx->GetMutex());
        //std::cout << "lock" << std::endl;
    }


    ~LockGuard()
    {
        pthread_mutex_unlock(&_mtx->GetMutex());
        //std::cout << "unlock" << std::endl;
    }
private:
    Mutex* _mtx;
};

Cond.hpp

#include "Common.h"
//封装条件变量目的：使条件变量可以初始化黑销毁
class Cond
{
public:
    Cond()
    {
        pthread_cond_init(&_cond, nullptr);
    }

    void Wait(pthread_mutex_t* _mtx)
    {
        pthread_cond_wait(&_cond,_mtx);
    }

    void WakeUp()
    {
        pthread_cond_signal(&_cond);
    }

    ~Cond()
    {
        pthread_cond_destroy(&_cond);
    }
private:
    pthread_cond_t _cond;
};

Benchmark.cc

测试线程池是否能用的代码：

#include "Common.h"
#include "ThreadPool.hpp"
#include "Task.hpp"
#include "Log.hpp"

int myAdd(int x, int y)
{
    return x + y;
}
int main()
{
    srand((unsigned long)time(nullptr) ^ getpid());
    // ThreadPool<Task>* tp = new ThreadPool<Task>;
    // tp->Run();

    ThreadPool<Task>::GetIstance()->Run();

    // std::cout << "main thread run......" << std::endl;
    LogMessage(NORMAL, "main thread runing");
    while (true)
    {
        int x = rand() % 100 + 1;
        int y = rand() & 30 + 1;

        Task t(x, y, myAdd);

        // std::cout << "Make a task: " << x << " + " << y << " =?" << std::endl;
        LogMessage(NORMAL, "%d + %d = ?", x, y);
        ThreadPool<Task>::GetIstance()->PushTask(t);
        sleep(1);
    }

    return 0;
}

Task.hpp

自定义的任务类

#pragma once
#include "Common.h"

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)
    {}

    int operator()()
    {
        return _func(_x, _y);
    }

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

Common.h

最后就是必须要用到的头文件，全部放在Common.h中

#pragma once
#include <iostream>
#include <vector>
#include <queue>
#include <string>
#include <functional>
#include <ctime>
#include <pthread.h>
#include <unistd.h>
#include <semaphore.h>
#include <stdarg.h>

#define THREAD_POOOL_NUM 3