设计线程池

于 2024-08-26 19:50:07 发布
阅读量113 收藏 2
点赞数 7
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77479435/article/details/141530275
版权 
sudo find ../.. -name Thread.hpp

查找Thread.hpp

cp ../../20240814/mythread/Thread.hpp .

通过cp命令进行拷贝

using namespace std;
void* run(void* args)
{
    string message=(const char*)args;
    while(true)
    {
        cout<<message<<endl;
        sleep(1);
    }
    return nullptr;
}

int main()
{
    ThreadNs::Thread t1(run,(void*)"thread 1 run");
    ThreadNs::Thread t2(run,(void*)"thread 2 run");

    t1.start();
    t2.start();

    t1.join();
    t2.join();
    return 0;
}

测试线程能否成功创建的代码

线程池效果：

thread-1 start ...
thread-2 start ...
thread-3 start ...
thread-4 start ...
thread-5 start ...
请输入数据1# 1
请输入数据2# 2
请输入要进行的运算# +
thread-3获取了一个任务: 1 + 2 = ? 并处理完成,结果是: 1 + 2 = 3 
请输入数据1# ^\Quit (core dumped) 

 LockGuard.hpp

#pragma once 

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

class Mutex
{
public:
    Mutex(pthread_mutex_t* lock_p=nullptr)
        :lock_p_(lock_p)
    {}
    void lock()
    {
        if(lock_p_)
            pthread_mutex_lock(lock_p_);
    }
    void unlock()
    {
        if(lock_p_)
        {
            pthread_mutex_unlock(lock_p_);
        }
    }
    ~Mutex()
    {}
private:
    pthread_mutex_t* lock_p_;
};
//在外部将锁初始化定义好，通过LockGuard的方式保护临界资源
class LockGuard
{
public:
    LockGuard(pthread_mutex_t* mutex):mutex_(mutex)
    {
        mutex_.lock();
    }
    ~LockGuard()
    {
        mutex_.unlock();
    }
private:
    Mutex mutex_;
};

ThreadPool.hpp

//写线程池的前提是有线程
#pragma once

#include"LockGuard.hpp"
#include"Thread.hpp"
#include<vector>
#include<queue>
#include<pthread.h>
#include<unistd.h>

using namespace std;
using namespace ThreadNs;

const int gnum=5;

template<class T>
class ThreadPool;
template<class T>
class ThreadData
{
public:
    ThreadPool<T>* threadpool;
    string name;
public:
    ThreadData(ThreadPool<T>* tp,const string& in)
        :threadpool(tp),name(in)
    {}
};
template<class T>
class ThreadPool
{
private:
    static void* handlerTask(void* args)
    {
        ThreadData<T>* td=(ThreadData<T>* )args;
        while(true)
        {
            //td->threadpool->lockQueue();
            T t;
            {
                LockGuard lockguard(td->threadpool->mutex());
                while(td->threadpool->isQueueEmpty())
                {
                    td->threadpool->threadWait();
                }
                t=td->threadpool->pop();//将任务从公共队列中，拿到当前线程独立的栈结构中
            }
            
            
            //td->threadpool->unlockQueue();
            cout<<td->name<<"获取了一个任务: "<<t.toTaskString()<<"并处理完成,结果是: "<<t()<<endl;
           //实现多个任务并发处理
        }
        delete td;
        return nullptr;
    }
public:
    void lockQueue(){pthread_mutex_lock(&_mutex);}
    void unlockQueue() {pthread_mutex_unlock(&_mutex);}
    bool isQueueEmpty() {return _task_queue.empty();}
    void threadWait() {pthread_cond_wait(&_cond,&_mutex);}
    T pop()
    {
        T t=_task_queue.front();
        _task_queue.pop();
        return t;
    }
    pthread_mutex_t* mutex()
    {
        return &_mutex;
    }
public:
    ThreadPool(const int& num=gnum)
        :_num(num)
    {
        pthread_mutex_init(&_mutex,nullptr);
        pthread_cond_init(&_cond,nullptr);
        for(int i=0;i<_num;i++)
        {
            _threads.push_back(new Thread());
        }
    }
    void run()
    {
        for(const auto& t:_threads)
        {
            ThreadData<T>* td=new ThreadData<T>(this,t->threadname());
            t->start(handlerTask,td);
            cout<<t->threadname()<<" start ..."<<endl;
        }
    }
    void push(const T& in)
    {
        //pthread_mutex_lock(&_mutex);
        LockGuard lockguard(&_mutex);
        _task_queue.push(in);
        pthread_cond_signal(&_cond);
        //pthread_mutex_unlock(&_mutex);
    }

    ~ThreadPool()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond);
        for(const auto& t:_threads) delete t;
    }
private:
    int _num;
    vector<Thread*> _threads;
    queue<T> _task_queue;
    pthread_mutex_t _mutex;
    pthread_cond_t _cond;
};

Task.hpp

#pragma once

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

using namespace std;
class Task
{
    using func_t=function<int(int,int,char)>;
    //typedef function<int(int,int)> func_t;
public:
    Task()
    {}
    Task(int x,int y,char op,func_t func):_x(x),_y(y),_op(op),_callback(func)
    {}
    string operator()()
    {
        int result=_callback(_x,_y,_op);
        //构建结构字符串
        char buffer[1024];
        snprintf(buffer,sizeof buffer,"%d %c %d = %d ",_x,_op,_y,result);
        return buffer;
    }
    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 _callback;
};
const string oper="+-*/";
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)
            {
                cerr<<"div zero error!!!"<<endl;
                result=-1;
            }
            else
                result=x/y;
        }
        break;
        case '%':
        {
            if(y==0)
            {
                cerr<<"mod zero error!!!"<<endl;
                result=-1;
            }
            else
                result=x%y;
        }          
        break;
        default:
        break;
    }
    return result;
}
class SaveTask
{
    typedef function<void(const string&)> func_t;
public:
    SaveTask()
    {}
    SaveTask(const string &message,func_t func)
    :_message(message),_func(func)
    {}
    void operator()()
    {
        _func(_message);
    }
private:
    string _message;
    func_t _func;
};
void Save(const string& message)
{
    const string target="./log.txt";
    FILE* fp=fopen(target.c_str(),"a+");
    if(!fp)
    {
        cerr<<" fopen error "<<endl;
        return;
    } 
    fputs(message.c_str(),fp);
    fputs("\n",fp);
    
    fclose(fp);
}

Thread.hpp

#pragma once

#include<cassert>
#include<iostream>
#include<string>
#include<functional>
#include<pthread.h>
using namespace std;
namespace ThreadNs
{
    typedef function<void*(void*)> func_t;
    const int num=1024;
    class Thread
    {
    private:
        //在类内创建线程，想让线程执行对应的方法，需要将方法设置为static
        static void *start_routine(void* args)//类内成员,有缺省参数!!!
        {
            Thread* _this=static_cast<Thread*>(args);
            //静态方法不能调用成员方法或者成员变量
            return _this->callback();
        }  
    public:
        //using func_t=function<void*(void*)>;
        Thread()
        {
            char buffer[num];//c99才支持用变量初始化数组
            //name_="thread-";
            //name_+=to_string(number);
            snprintf(buffer,sizeof buffer,"thread-%d",threadnum++);
            name_=buffer;
        }
        void start(func_t func,void *args=nullptr)
        {
            func_=func;
            args_=args;
            int n=pthread_create(&tid_,nullptr,start_routine,this);
        }
        void join()
        {
            int n=pthread_join(tid_,nullptr);
        }
        string threadname()
        {
            return name_;
        }
        void *callback()
        {
            return func_(args_); 
        }
    private:
        string name_;
        pthread_t tid_;
        func_t func_;//线程要执行的方法
        void *args_;//线程执行时对应的参数

        static int threadnum;
    };
    int Thread::threadnum=1;
}

 main.cc

#include"ThradPool.hpp"
#include"Thread.hpp"
#include"Task.hpp"
#include<memory>
#include<unistd.h>


using namespace std;
int main()
{
    unique_ptr<ThreadPool<Task> > tp(new ThreadPool<Task>());
    tp->run();
    int x,y;
    char op;
    while(1)
    {
        cout<<"请输入数据1# ";
        cin>>x;
        cout<<"请输入数据2# ";
        cin>>y;
        cout<<"请输入要进行的运算# ";
        cin>>op;
        Task t(x,y,op,mymath);
        tp->push(t);
        sleep(1);
    }
    return 0;
}
wc -l *
   42 LockGuard.hpp
   27 main.cc
    4 Makefile
  109 Task.hpp
   71 Thread.hpp
  118 threadpool
  114 ThreadPool.hpp
  485 total

查看代码行数

添加单例模式（懒汉模式）

ThreadPool.hpp

//写线程池的前提是有线程
#pragma once

#include"LockGuard.hpp"
#include"Thread.hpp"
#include<vector>
#include<queue>
#include<pthread.h>
#include<unistd.h>

using namespace std;
using namespace ThreadNs;

const int gnum=5;

template<class T>
class ThreadPool;
template<class T>
class ThreadData
{
public:
    ThreadPool<T>* threadpool;
    string name;
public:
    ThreadData(ThreadPool<T>* tp,const string& in)
        :threadpool(tp),name(in)
    {}
};
template<class T>
class ThreadPool
{
private:
    static void* handlerTask(void* args)
    {
        ThreadData<T>* td=(ThreadData<T>* )args;
        while(true)
        {
            //td->threadpool->lockQueue();
            T t;
            {
                LockGuard lockguard(td->threadpool->mutex());
                while(td->threadpool->isQueueEmpty())
                {
                    td->threadpool->threadWait();
                }
                t=td->threadpool->pop();//将任务从公共队列中，拿到当前线程独立的栈结构中
            }
            
            
            //td->threadpool->unlockQueue();
            cout<<td->name<<"获取了一个任务: "<<t.toTaskString()<<"并处理完成,结果是: "<<t()<<endl;
           //实现多个任务并发处理
        }
        delete td;
        return nullptr;
    }
    ThreadPool(const int& num=gnum)
        :_num(num)
    {
        pthread_mutex_init(&_mutex,nullptr);
        pthread_cond_init(&_cond,nullptr);
        for(int i=0;i<_num;i++)
        {
            _threads.push_back(new Thread());
        }
    }
    void operator=(const ThreadPool &)=delete;
    ThreadPool(const ThreadPool &)=delete;
public:
    void lockQueue(){pthread_mutex_lock(&_mutex);}
    void unlockQueue() {pthread_mutex_unlock(&_mutex);}
    bool isQueueEmpty() {return _task_queue.empty();}
    void threadWait() {pthread_cond_wait(&_cond,&_mutex);}
    T pop()
    {
        T t=_task_queue.front();
        _task_queue.pop();
        return t;
    }
    pthread_mutex_t* mutex()
    {
        return &_mutex;
    }
public:
    
    void run()
    {
        for(const auto& t:_threads)
        {
            ThreadData<T>* td=new ThreadData<T>(this,t->threadname());
            t->start(handlerTask,td);
            cout<<t->threadname()<<" start ..."<<endl;
        }
    }
    void push(const T& in)
    {
        //pthread_mutex_lock(&_mutex);
        LockGuard lockguard(&_mutex);
        _task_queue.push(in);
        pthread_cond_signal(&_cond);
        //pthread_mutex_unlock(&_mutex);
    }

    ~ThreadPool()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond);
        for(const auto& t:_threads) delete t;
    }
    static ThreadPool<T>* getInstance()
    {
        if(nullptr==tp)
        {
            tp=new ThreadPool<T>();
        }
        return tp;
    }
private:
    int _num;
    vector<Thread*> _threads;
    queue<T> _task_queue;
    pthread_mutex_t _mutex;
    pthread_cond_t _cond;
    //设计静态指针
    static ThreadPool<T>* tp;
    
};
template<class T>
ThreadPool<T>* ThreadPool<T>::tp=nullptr;

main.cc

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


using namespace std;
int main()
{
    //unique_ptr<ThreadPool<Task> > tp(new ThreadPool<Task>());
    //tp->run();
    ThreadPool<Task>::getInstance()->run();
    int x,y;
    char op;
    while(1)
    {
        cout<<"请输入数据1# ";
        cin>>x;
        cout<<"请输入数据2# ";
        cin>>y;
        cout<<"请输入要进行的运算# ";
        cin>>op;
        Task t(x,y,op,mymath);
        //tp->push(t);
        ThreadPool<Task>::getInstance()->push(t);
        sleep(1);
    }
    return 0;
}
while :; do ps -aL | grep threadpool; sleep 1; echo "##################"; done

监视threadpool进程

    //设计静态指针
    static ThreadPool<T>* tp;//没有实例化出对象
    static mutex _singlock;
};
//只有定义了对象模版才会实例化
template<class T>//对于指针类型明确后才能赋值
ThreadPool<T>* ThreadPool<T>::tp=nullptr;
//void 不明确 void*可以设为指针
template<class T>
mutex ThreadPool<T>::_singlock;

铁蛋Q
关注
  • 7
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
掰开揉碎了教你设计线程池，还不来学？
hailong66666的博客
12-03 422
线程池设计思路 线程池是什么 我们先来打个比方，线程池就好像一个工具箱，我们每次需要拧螺丝的时候都要从工具箱里面取出一个螺丝刀来，有时候需要取出一个来拧，有时候螺丝多的时候需要多个人取出多个来拧，拧完自己的螺丝那么就会把螺丝刀再放回去，然后别人下次用的时候再取出来用。也许我的例子不是太完美，但是我想我已经基本阐述清楚了线程池。说白了线程池就是相当于提前申请了一些资源也就是线程，需要的时候就从线程池中取出线程来处理一些事情，处理完毕之后再把线程放回去。 为什么需要线程池 我们来思考一个问题，为什么需要线程池
你还不懂线程池的设计及原理吗？掰开揉碎了教你设计线程池
Linuxhus的博客
06-11 230
大家在学习线程池的时候也曾查阅过各种资料，但是感觉大佬写的很好但是写的不够详细，写的详细的设计思路又很简单，所以我的出发点就是让读者可以清晰明确的看懂整个设计思想和设计过程，可以举一反三，在今后内存池等方面也可以游刃有余的设计出来！好了，正文开始~我们先来打个比方，线程池就好像一个工具箱，我们每次需要拧螺丝的时候都要从工具箱里面取出一个螺丝刀来，有时候需要取出一个来拧，有时候螺丝多的时候需要多个人取出多个来拧，拧完自己的螺丝那么就会把螺丝刀再放回去，然后别人下次用的时候再取出来用。也许我的例子不是太完美，但
如何设计线程池
bfj11的博客
03-07 865
如何设计线程池
线程池设计要点
wangbuji的博客
03-17 566
应用场景： 1. 高并发、任务执行时间短的业务怎样使用线程池？ 2. 并发不高、任务执行时间长的业务怎样使用线程池？ 3. 并发高、业务执行时间长的业务怎样使用线程池？ 线程池本质上是生产者和消费者模型，包括三要素： 往线程池队列中投递任务的生产者； 任务池队列； 从任务池队列取出任务执行的 worker 线程（消费者）。 线程池任务特性： 1 根据任务的性质来分： CPU 密集型任务； IO 密集型任务； 混合型任务。 2 根据任务
自己设计线程池，要从哪些方面考虑
weixin_43337246的博客
06-28 662
1.高并发、任务执行时间段 的业务使用什么样的线程池 2.并发不高、任务执行时间长的的业务怎样使用线程池 3.并发搞、业务执行时间长的业务怎样使用线程池 线程池的本质是生产者和消费者模型，包括三要素： 往线程队列中投递任务的生产者 任务池队列 从任务池队列取出任务执行的worker线程（消费者） 想要合理配置线程池的大小，就要分析线程池任务的特性，可以从以下几个方面进行分析： 根据任务性质分： cpu密集型 IO密集型 混合型任务 根据任务的优先级： 高 中 低 根据任务的执行时间： 长 中
【Java】如何根据 CPU 核心数设计线程池线程数量
qq_44544908的博客
02-26 899
CPU密集型任务主要消耗CPU资源进行计算，当任务为CPU密集型时，核心池线程数设置为CPU核数+1即可；一般来说池中总线程数是核心池线程数量两倍，只要确保当核心池有线程停止时，核心池外能有线程进入核心池即可。I/O密集型任务，核心池线程数量大小应在CPU核数两倍以上且不宜过多。所以说，将线程池的核心池线程数量配置为CPU核数的两倍是比较合适的。
系统编程之线程池、如何设计这个任务工作链表和如何设计线程池？ 、 使用 命令 grep -r “关键字“ 路径
weixin_42191545的博客
02-22 224
系统编程之线程池 在进程中，创建多个线程，每当有任务执行时，直接调用已创建好的线程执行，不需要额外创建线程。 实际情况是线程的数量受限于计算机内存不能创建太多，那么就可以利用线程池设置线程数量上限 ...
基于Java线程池技术的数据爬虫设计与实现.pdf
07-02
在实际开发中，需要注意线程安全问题，合理设计线程池的大小，以及合理配置线程池中线程的参数，以达到最优的性能表现。通过这些方法，数据爬虫可以在保证高效爬取数据的同时，还能保持良好的系统资源利用率。
C语言：文件（写入，读取）
2301_80311224的博客
08-21 746
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
【C++】链表
qq_38801607的博客
08-22 569
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
C++ 重载运算符和重载函数
最新发布
lly202406的博客
08-25 476
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
C语言破墙镐对称飞迷宫
qq_69383179的博客
08-22 1317
这里有我用C语言编译的破墙镐对称飞迷宫和与之相关的一些东西
c语言用if语句制作点单程序
2301_81968528的博客
08-20 293
printf("数字1代表喝咖啡，数字2代表喝雪碧:");这里的点单程序是用户输入相应的数字自动出来相应的饮品。puts("您要喝的是咖啡");puts("您要喝雪碧");比如输入1是咖啡，输入2是雪碧。c语言里面，if语句的语法是。
C++ 基础
weixin_51883798的博客
08-22 281
MyClass&& other:这是一个右值引用参数，指向要移动的对象。右值引用允许我们访问即将被销毁的对象，从中“窃取”资源。该关键字表示移动构造函数不会抛出异常。这是一个优化提示，告诉编译器在需要时可以安全地使用移动构造函数。这是C++11标准中新引入的一个特性，旨在提高性能，尤其是在涉及临时对象和资源管理时。特殊的成员函数，允许将一个对象的状态转移到另一个新创建的对象中，不需要进行复制。
Java以JNI形式调用C/C++动态库实现回调方法
liuyuxuan2388的博客
08-24 390
由于我需要做的是在DLL中的一个线程里改变某个java对象的值,所以,还必须获取那个java对象的jobject指针.同 JNIEnv 指针一样,jobject指针也不能在多个线程中共享. 就是说,不能直接在保存一个线程中的jobject指针到全局变量中,然后在另外一个线程中使用它.幸运的是,可以用。然而JNI文档上说，JNI接口的指针JNIEnv*不能在c++的线程间共享，在我的程序中，如果接收线程试图调用java对象的方法，程序会突然退出。Java生成.h头文件（以Test.java为例）
c++11（三）
qhy850716的博客
08-21 1109
function<返回类型(参数包类型)> fc;
安装CUDA的常见错误：cuda_install_131.log
weixin_53028400的博客
08-23 282
安装CUDA的常见错误：cuda_install_131.log解决
初识顺序表---C语言
weixin_74202161的博客
08-23 342
顺序表是一种以数组为基础的结构，对数组进行封装，实现常用的增删改查等操作的。//销毁。
c++设计线程池类启用单个线程的流程以及示例
06-02
启用单个线程的线程池类示例代码如下： ```cpp #include #include #include #include #include #include class ThreadPool { public: ThreadPool() : stopped(false) {} ~ThreadPool() { stop(); } ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值