linux线程池

最新推荐文章于 2024-09-03 16:00:00 发布
最新推荐文章于 2024-09-03 16:00:00 发布
阅读量865 收藏 5
点赞数 6
文章标签： linux java 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zengkui198513/article/details/138871160
版权

经过前面的阻塞队列和环形阻塞队列的学习。我们现在来实现一下多线程
/threadpool.h/
/* 线程池:

  • 一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。可用线程数量应该取决于可用的并发处理器、处理器内核、内存、网络sockets等的数量。
  • 线程池的应用场景：
    1. 需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。 但对于长时间的任务，比如一个Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。
    1. 对性能要求苛刻的应用，比如要求服务器迅速响应客户请求。
    1. 接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用。突发性大量客户请求，在没有线程池情况下，将产生大量线程，虽然理论上大部分操作系统线程数目最大值不是问题，短时间内产生大量线程可能使内存到达极限，
      出现错误.
  • 线程池的种类：
  • 线程池示例：
    1. 创建固定数量线程池，循环从任务队列中获取任务对象，
    1. 获取到任务对象后，执行任务对象中的任务接口
      */

实现步骤1，我们先自定义一个线程类

这个类的解析：
1 我们先定义一个函数类型
申明一个返回值是void* 参数是void*的一个函数

typedef std::function<void*(void*)> func_t;

2 构造函数
这个构造函数和之前写的构造函数不一样，这里构造函数只是为了初始化_name属性。

    Thread()
    {
        char buffer[num];
        snprintf(buffer, sizeof buffer,"thread-%d",threadnum++);
        _name = buffer;
    }

3 start函数，我们把对线程的初始化放到了start函数里面并且通过传递this指针的方式，将本个类的属性传过去。

    void start(func_t func,void *args=nullptr)
    {
        // Context* ctx = new Context();
        // ctx->_this=this;
        // ctx->_args =_args;
        _func =func;
        _args =args;
        int n = pthread_create(&_tid, nullptr, start_routine, this);
        assert(n == 0); //编译debug的方式发布的时候存在，release方式发布，assert就不存在了，n就是一个定义了，但是没有被使用的变量
        // 在有些编译器下会有warning
        (void)n;
    }

4 start_routine创建线程执行的函数

    static void* start_routine(void*args)
    {
        Thread* _this = static_cast<Thread*>(args);
        // Context *ctx = static_cast<Context *>(args);
        // void *ret = ctx->_this->_func();
        // delete ctx;
        // return ret;
        return _this->callback();
    }

完成的代码

#pragma once
#include<iostream>
#include<string>
#include<pthread.h>
#include <stdio.h>
#include<unistd.h>
#include <functional>
#include<cassert>

// 首先我们需要什么 ， 名字 ，id ，需要的执行的函数, 还有线程属性可以包括线程的堆栈大小、调度策略、分离状态等。

// class Thread;

//上下文,当成一个大号的结构体
// class Context
// {
//     typedef std::function<void*(void*)> func_t;
// public:
//     Thread *_this;
//     void *_args;
//     func_t func;
// public:
//     Context():_this(nullptr), _args(nullptr),_func(nullptr)
//     {}
//     ~Context()
//     {}
// };


class Thread
{
private:
    static void* start_routine(void*args)
    {
        Thread* _this = static_cast<Thread*>(args);
        // Context *ctx = static_cast<Context *>(args);
        // void *ret = ctx->_this->_func();
        // delete ctx;
        // return ret;
        return _this->callback();
    }
public:
    // 这里就是申明了一种函数类型
    typedef std::function<void*(void*)> func_t;
    const int num = 1024;
public:
    Thread()
    {
        char buffer[num];
        snprintf(buffer, sizeof buffer,"thread-%d",threadnum++);
        _name = buffer;
    }

    void join()
    {
        int n = pthread_join(_tid, nullptr);
        assert(n == 0);
        (void)n;
    }

    void start(func_t func,void *args=nullptr)
    {
        // Context* ctx = new Context();
        // ctx->_this=this;
        // ctx->_args =_args;
        _func =func;
        _args =args;
        int n = pthread_create(&_tid, nullptr, start_routine, this);
        assert(n == 0); //编译debug的方式发布的时候存在，release方式发布，assert就不存在了，n就是一个定义了，但是没有被使用的变量
        // 在有些编译器下会有warning
        (void)n;
    }

    std::string threadname()
    {
        return _name;
    }
     void *callback() 
    { 
        return _func(_args);
    }

    ~Thread()
    {
        // do nothing
    }
private:
    std::string _name; // 线程名字
    pthread_t _tid;   // 线程id
    void* _args; // 这个其实是pthread_create 函数的const pthread_attr_t attr属性 。             // 如果传入 NULL，线程将使用默认属性创建。线程属性可以包括线程的堆栈大小、调度策略、分离状态等。
    func_t _func; // 执行的任务函数
    static int threadnum;
};
 int Thread::threadnum = 1;

任务类Task.hpp,定义一种任务并且有一个函数对应

#pragma once
#include <functional>
#include <stdio.h>
#include <string>
#include <iostream>

class Task
{
public:
    // 申明一种函数类型
    using func_t = std::function<int(int, int, char)>;

    // 构造方法
    Task() {}
    Task(int x, int y, char op, func_t func)
        : _x(x), _y(y), _op(op), _func(func)
    {
    }

    std::string operator()()
    {
        int result = _func(_x, _y, _op);
        char buffer[1024];
        snprintf(buffer, sizeof buffer, "%d %c %d=%d", _x, _op, _y, result);
        return buffer;
    }
    std::string toTaskString()
    {
        char buffer[1024];
        snprintf(buffer, sizeof buffer, "%d %c %d = ?", _x, _op, _y);
        return buffer;
    }

private:
    int _x;
    int _y;
    char _op;
    func_t _func;
};

int mymath(int x, int y, char op)
{
    int result = 0;
    switch (op)
    {
    case '+':
        result = x + y;
        break;
    case '-':
        result = x - y;
        break;
    case '*':
        result = x * y;
        break;
    case '/':
        if (y == 0)
        {
            std::cout << "除0错误" << std::endl;
        }
        result = x / y;
        break;
    case '%':
        if (y == 0)
        {
            std::cerr << "mod zero error!" << std::endl;
            result = -1;
        }
        else
            result = x % y;
            break;
    default:
        break;
    }
    return result;
}

线程池类。重点

#include "Thread.hpp"
#include "Mutex.hpp"
#include <vector>
#include <queue>
#include <mutex>
#include <pthread.h>
const int gnum = 3;

template <class T>
class ThreadPool;

template <class T>
class ThreadData
{
public:
    ThreadPool<T> *threadPool;
    std::string name;

public:
    ThreadData(ThreadPool<T> *tp, const std::string &n)
        : threadPool(tp), name(n)
    {
    }
};

template <class T>
class ThreadPool
{
private:
    static void *handlerTask(void *args)
    {
        ThreadData<T> *td = static_cast<ThreadData<T> *>(args);
        while (true)
        {
            T t;
            {
                LockGuard LockGuard(td->threadPool->getMutex());
                // std::cout << td->threadPool->isQueueEmpty() << std::endl;
                while (td->threadPool->isQueueEmpty())
                {
                    td->threadPool->threadWait();
                }
                t = td->threadPool->pop();
            }

            std::cout << td->name << " 获取了一个任务： " << t.toTaskString() << " 并处理完成，结果是：" << t() << std::endl;
        }
        delete td;
        return nullptr;
    }
    

public:
	ThreadPool(int num = gnum)
        : _num(num)
    {
        pthread_mutex_init(&_mutex, nullptr);
        pthread_cond_init(&_cond, nullptr);

        for (int i = 0; i < _num; i++)
        {
            _thread.push_back(new Thread());
        }
    }
    void push(const T &t)
    {
        LockGuard lockguard(&_mutex);
        _queue.push(t);
        pthread_cond_signal(&_cond);
    }
    // 判断任务队列是否为空
    bool isQueueEmpty()
    {
        return _queue.empty();
    }
    void lockQueue()
    {
        pthread_mutex_lock(&_mutex);
    }

    void unlockQueue()
    {
        pthread_mutex_unlock(&_mutex);
    }

    void threadWait()
    {
        pthread_cond_wait(&_cond, &_mutex);
    }

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

    void run()
    {
        for (const auto &t : _thread)
        {
            ThreadData<T> *td = new ThreadData<T>(this, t->threadname());
            t->start(handlerTask, td);
            std::cout << t->threadname() << " start ..." << std::endl;
        }
    }

    pthread_mutex_t *getMutex()
    {
        return &_mutex;
    }
    ~ThreadPool()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond);
        // 验证一下这里的类型
        for (const auto &t : _thread)
        {
            delete t;
        }
    }


private:
    int _num;                      // 你创建线程的数量
    std::queue<T> _queue;          // 这里我查了，stl容器基于链表实现的 // 充当任务队列
    std::vector<Thread *> _thread; // 线程池的线程，用vector管理
    pthread_mutex_t _mutex;        // 定义一个锁对象
    pthread_cond_t _cond;          // 定义条件变量

};

构造函数

对成员属性初始化

    ThreadPool(int num = gnum)
        : _num(num)
    {
        pthread_mutex_init(&_mutex, nullptr);
        pthread_cond_init(&_cond, nullptr);

        for (int i = 0; i < _num; i++)
        {
            _thread.push_back(new Thread());
        }
    }

Run函数

这里回去调用线程类的start方法。

    void run()
    {
        for (const auto &t : _thread)
        {
            ThreadData<T> *td = new ThreadData<T>(this, t->threadname());
            t->start(handlerTask, td);
            std::cout << t->threadname() << " start ..." << std::endl;
        }
    }

handlerTask方法

static void *handlerTask(void *args)
    {
        ThreadData<T> *td = static_cast<ThreadData<T> *>(args);
        while (true)
        {
            T t;
            {
                LockGuard LockGuard(td->threadPool->getMutex());
                // std::cout << td->threadPool->isQueueEmpty() << std::endl;
                while (td->threadPool->isQueueEmpty())
                {
                    td->threadPool->threadWait();
                }
                t = td->threadPool->pop();
            }

            std::cout << td->name << " 获取了一个任务： " << t.toTaskString() << " 并处理完成，结果是：" << t() << std::endl;
        }
        delete td;
        return nullptr;
    }

在这里插入图片描述

test.cc

#include"ThreadPool.hpp"
#include "Task.hpp"
#include <memory>
#include <unistd.h>

int main()
{
    ///一大堆的代码...

    // std::unique_ptr<ThreadPool<Task> > tp(new ThreadPool<Task>());
    ThreadPool<Task>::getInstance()->run();
    // tp->run();

    int x, y;
    char op;
    while(1)
    {
        std::cout << "请输入数据1# ";
        std::cin >> x;
        std::cout << "请输入数据2# ";
        std::cin >> y;
        std::cout << "请输入你要进行的运算#";
        std::cin >> op;
        Task t(x, y, op, mymath);
        // std::cout << "你刚刚录入了一个任务: " << t.toTaskString() << ", 确认提交吗？[y/n]# ";
        // char confirm;
        // std::cin >> confirm;
        // if(confirm == 'y') tp->push(t);
        ThreadPool<Task>::getInstance()->push(t);
        sleep(1);
    }
}

线程池其实是一个单例，将线程池的设计变为单例模式

#include "Thread.hpp"
#include "Mutex.hpp"
#include <vector>
#include <queue>
#include <mutex>
#include <pthread.h>
const int gnum = 3;

template <class T>
class ThreadPool;

template <class T>
class ThreadData
{
public:
    ThreadPool<T> *threadPool;
    std::string name;

public:
    ThreadData(ThreadPool<T> *tp, const std::string &n)
        : threadPool(tp), name(n)
    {
    }
};

template <class T>
class ThreadPool
{
private:
    static void *handlerTask(void *args)
    {
        ThreadData<T> *td = static_cast<ThreadData<T> *>(args);
        while (true)
        {
            T t;
            {
                LockGuard LockGuard(td->threadPool->getMutex());
                // std::cout << td->threadPool->isQueueEmpty() << std::endl;
                while (td->threadPool->isQueueEmpty())
                {
                    td->threadPool->threadWait();
                }
                t = td->threadPool->pop();
            }

            std::cout << td->name << " 获取了一个任务： " << t.toTaskString() << " 并处理完成，结果是：" << t() << std::endl;
        }
        delete td;
        return nullptr;
    }
    ThreadPool(int num = gnum)
        : _num(num)
    {
        pthread_mutex_init(&_mutex, nullptr);
        pthread_cond_init(&_cond, nullptr);

        for (int i = 0; i < _num; i++)
        {
            _thread.push_back(new Thread());
        }
    }

public:
    void push(const T &t)
    {
        LockGuard lockguard(&_mutex);
        _queue.push(t);
        pthread_cond_signal(&_cond);
    }
    // 判断任务队列是否为空
    bool isQueueEmpty()
    {
        return _queue.empty();
    }
    void lockQueue()
    {
        pthread_mutex_lock(&_mutex);
    }

    void unlockQueue()
    {
        pthread_mutex_unlock(&_mutex);
    }

    void threadWait()
    {
        pthread_cond_wait(&_cond, &_mutex);
    }

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

    void run()
    {
        for (const auto &t : _thread)
        {
            ThreadData<T> *td = new ThreadData<T>(this, t->threadname());
            t->start(handlerTask, td);
            std::cout << t->threadname() << " start ..." << std::endl;
        }
    }

    pthread_mutex_t *getMutex()
    {
        return &_mutex;
    }
    ~ThreadPool()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond);
        // 验证一下这里的类型
        for (const auto &t : _thread)
        {
            delete t;
        }
    }
    static ThreadPool<T> *getInstance()
    {
        if (nullptr == tp)
        {
            _singlock.lock();
            if (nullptr == tp)
            {
                tp = new ThreadPool<T>();
            }
            _singlock.unlock();
        }
        return tp;
    }

private:
    int _num;                      // 你创建线程的数量
    std::queue<T> _queue;          // 这里我查了，stl容器基于链表实现的 // 充当任务队列
    std::vector<Thread *> _thread; // 线程池的线程，用vector管理
    pthread_mutex_t _mutex;        // 定义一个锁对象
    pthread_cond_t _cond;          // 定义条件变量
    static std::mutex _singlock;
    static ThreadPool<T> *tp;
};

template <class T>
ThreadPool<T> *ThreadPool<T>::tp = nullptr;
template <class T>
std::mutex ThreadPool<T>::_singlock; //这是std里面的mutex ,跟linux里面的不一样
小曾同学杀疯了
关注
  • 6
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
linux线程池，c语言实现
01-06
Linux线程池是一种高效的任务调度机制，它通过预先创建一组线程来处理任务，而不是每次需要执行任务时都创建新的线程。这种设计可以避免频繁地创建和销毁线程带来的开销，提高系统的响应速度和资源利用率。在C语言中...
Linux 线程池
09-03
【Linux 线程池】 线程池是操作系统或编程语言中的一种并发处理机制，它是一种高效的资源管理和任务调度方式。在Linux系统中，通过利用线程池，开发者可以有效地控制并发执行的任务数量，减少线程创建和销毁的开销...
linux 线程池原理以及实现
02-12 583
线程池实现
Linux线程池
qq_55317476的博客
06-29 550
​ 线程池是线程的一种使用模式。在前面的情况中，我们都是遇到任务然后创建线程再执行。但是线程的频繁创建就类似于内存的频繁申请，会给操作系统带来更大的压力，进而影响整体的性能。​ 所以我们一次申请好一定数量的线程，然后将线程的管理操作交给线程池，就避免了在短时间内不断创建与销毁线程的代价，线程池不但能够保证内核的充分使用，还能防止过度调度，并根据实际业务情况进行修改。
Linux线程池的原理及实现
koko_TT的博客
07-18 2847
01 为什么需要线程池 首要明白两个地方： 线程的创建需要内存资源 线程的创建和销毁需要时间资源 显而易见，由于以上两个原因，不得不寻找一个折衷的方式面对多任务的问题。如果我们只创建一定量的线程，且在一个线程执行完某一任务后，重复利用该线程去处理新的任务而不是直接销毁它，那么通过这两个策略我们就可以“朴素”的解决以上两个问题。 线程池的初衷就是想搭建一个有一定数量线程，且可以重复利用这些线程处...
Linux之线程池
2303_77100822的博客
10-27 707
并且我们会发现这3个线程在处理时会呈现出一定的顺序性，因为主线程是每秒push一个任务，这3个线程只会有一个线程获取到该任务，其他线程都会在等待队列中进行等待，当该线程处理完任务后就会因为任务队列为空而排到等待队列的最后，当主线程再次push一个任务后会唤醒等待队列首部的一个线程，这个线程处理完任务后又会排到等待队列的最后，因此这3个线程在处理任务时会呈现出一定的顺序性。：指的就是一个类只能创建一个对象，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。
【Linux线程池】
qq_68472674的博客
02-24 405
Linux线程池
Linux——线程池
m0_69323023的博客
06-10 2154
Linux---线程池
linux 线程池编程,Linux-C-9-线程池编程
weixin_33199715的博客
05-10 163
线程池线程池：因为线程在频繁的进行创建和销毁过程中浪费CPU资源，线程池就是把一堆线程放在一个池子里面进行统一管理；线程池工作流程：1、初始化线程池，任务队列和工作线程；2、向任务队列中添加任务；3、将等候在条件变量(任务队列上有任务)上的一个线程唤醒并从该任务队列中取出第一个任务给该线程执行；4、等待任务队列中所有任务执行完毕5、关闭线程池；线程池的构成任务队列job_queue:用于存放待处理...
linux C 线程池
zhuguanlin121的博客
12-29 763
linux C 线程池
Linux 线程池源码分析
11-12
非常详细的线程池函数接口分析，可以帮助初学者加深对线程池的理解，更好的去把线程池运用到实例中去，线程池就是多个线程组合在一起的集合，就像一家公司一样，由多个员工组成的一个集合，当有任务时， 这些线程就...
linux线程池代码（c++实现）
04-15
在Linux系统中，线程池是一种高效的多线程管理机制，它通过预先创建一组线程，然后将任务分配给这些线程执行，从而避免频繁地创建和销毁线程带来的开销。C++作为一门强大的系统编程语言，可以方便地实现线程池。下面...
在Ubuntu/Linux下重温FC游戏——超级玛丽奥
bluebird_shao的专栏
09-02 1443
FC 模拟器是指能够在某种机器上运行 FC 游戏的程序，FC 模拟器有好几种，Linux 平台下的 FCEUX 是一款功能强大的免费 FC/NES 模拟器，你可以使用它重温那些经典的游戏。
【运维监控】prometheus+node exporter+grafana 监控linux机器运行情况（2）
最新发布
alanchanchn的专栏
09-03 1836
本示例是通过prometheus的node exporter收集主机的信息，然后在grafana的dashborad进行展示。本示例使用到的组件均是最新的，下文中会有具体版本说明，linux环境是centos。本示例分为四个部分，即prometheus、grafana、node exporter的部署和三者集成的监控linux。本文旨在说明三者如何使用，不涉及各自组件的介绍，如果需要使用到本文的，肯定都有了解。
Linux 命令行快捷键
sun007700的专栏
08-30 694
涉及在linux命令行下进行快速移动光标、命令编辑、编辑后执行历史命令、Bang(!Ctrl+y: 粘贴Ctrl+u或ctrl+k剪切的内容。Alt – d ：由光标位置开始，往右删除单词。Alt – d: 先按住 Alt 键，然后再按 d 键；Ctrl+u：删除当前光标前面的文字 (还有剪切功能)Ctrl+k：删除当前光标后面的文字 (还有剪切功能)M – k：先单击 Esc 键，然后再按 k 键。Ctrl+w: 删除光标前面的单词。Ctrl+左右键:在单词之间跳转。Ctrl+a: 跳到本行的行首。
【Linux】08.Linux 下的第一个小程序——进度条
caryon的博客
09-02 582
对换行与回车的直观解释，认识缓冲区，编写小程序
深入理解Linux线程池源码与实战应用
本文档深入剖析了Linux环境下C语言实现的...本文档提供了一个完整的Linux线程池实现的剖析，适合对多线程编程感兴趣的开发者深入理解线程池的内部工作机制，并掌握如何在C语言项目中有效利用线程池来管理和调度任务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值