Linux 之C++ 线程池

最新推荐文章于 2023-05-23 14:22:47 发布
最新推荐文章于 2023-05-23 14:22:47 发布
阅读量413 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dasgk/article/details/48391669
版权

       我想做的就是对每个线程进行有针对性的控制，也即可以对线程进行暂停，恢复，退出等等精细控制，对于此项要求，我的想法是声明一个类，该类中有些精细的操作其中包括该线程的状态，对线程控制的互斥变量（pthread_mutex_t），以及唤醒的条件（pthread_cond_t）,要实现这些功能其核心在于，每个线程拥有自己的控制变量，也即线程执行函数是线程类的静态函数，该线程函数的参数是该线程类对象的this指针！！！

class Servant
{
	private:

		pthread_mutex_t mutex_x;
		pthread_cond_t cond_t;
		int state;
	public:
		pthread_t m_tid;
		Servant();
		void start();
	static void* ThreadProc(void* data);
		void notify();
		void stop();
		void wakeup();
		void exit();
		void join();
};
这是该线程类的声明，最主要的是查看ThreadProc静态函数 

void* Servant::ThreadProc(void* data)
{    
    Servant* ser=(Servant*)data;
    int result=0;
    while(ser->state!=EXIT)
    {
        while(ser->state==IDLE)
        {
            result=pthread_mutex_lock(&(ser->mutex_x));
            if(0==result)
            {
                printf("waiting for the mutex \n");
            }            
            result=pthread_cond_wait(&(ser->cond_t),&(ser->mutex_x));    
            if(ser->state!=IDLE)
                goto End;
                
            printf("the conditions has been notified\n");
            //we take this thread to busy list
            ser->m_pool->AddtoIdle(false,ser);
            ser->m_pool->Addtobusy(true,ser);
            // really   work
            
            DoSomething:
            ser->state=WORKING;            
            printf("Do Something...\n");
            ser->DoJob();
            ser->Complete();//this function change state
            End:
            pthread_mutex_unlock(&(ser->mutex_x));                    
        }
    }
    return NULL;
}
这函数，主要控制的就两项，其一state，每次对线程状态的改变，都是基于原子线程已经执行完毕的基础上的，也即，核心操作是不能被状态的改变所修改的。每次被唤醒时，都需要进行检测state的值，如果STATE还是RUN，则表明有新的任务要处理，否则表明唤醒只是为了要修改当前线程状态！！！，现在看一下一个API

pthread_cond_wait，该函数调用时首先必须必须由本线程加锁，这个函数需要两个变量一个是mutex_x（加锁的互斥变量）和cond_t（条件变量），在更新条件以前，mutex_x一直保持锁定状态，并在线程挂起进入等待解锁，当执行pthread_cond_singal时，激活互斥变量mutex，并向下执行，当离开pthread_cond_wait时，重新加锁

现Servant.h文件内容如下：

#include<pthread.h>
#include<vector>
using namespace std;
class Servant
{
	private:

		pthread_mutex_t mutex_x;
		pthread_cond_t cond_t;
		int state;
	public:
		pthread_t m_tid;
		Servant();
		void start();
	static void* ThreadProc(void* data);
		void notify();
		void stop();
		void wakeup();
		void exit();
		void join();
};
//ServantPool supposed to be singlton
class ServantPool
{
private:
	vector<Servant*> m_idle_list;
	vector<Servant*> m_busy_list;
	ServantPool(){};
	static ServantPool * hInstance;
public:	
	void TerminateAll();
	void create(int num);
	void start();
	void stop(pthread_t id);
	void wakeup(pthread_t id);
	void waitforAll();
	~ServantPool();	
	static ServantPool * getInstance();	
};

Servant.cpp文件内容如下： 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#include"Servant.h"
#define WORKING 1
#define STOP 2
#define EXIT 3
#define IDLE 4
static int num=0;
static     pthread_mutex_t vec_mutex; 
void Servant::start()
{
    state=IDLE;
    int result=pthread_create(&m_tid,NULL,ThreadProc,this);
    if(0!=result)
    {
        printf("thread create result :%s\n",strerror(errno));
    }
}
Servant::Servant(ServantPool* ma)
{    
    thread_id=num++;
    m_pool=ma;    
    pthread_mutex_init(&mutex_x,NULL);
    pthread_cond_init(&cond_t,NULL);    
}
void Servant::setSocket(int m)
{
    m_socket=m;
}
void Servant::DoJob()
{
    char buf[100]={0};
    recv(m_socket,buf,100,0);
    printf("we haved the %d recv:%s\n",num++,buf);
    close(m_socket);
}
void* Servant::ThreadProc(void* data)
{    
    Servant* ser=(Servant*)data;
    int result=0;
    while(ser->state!=EXIT)
    {
        while(ser->state==IDLE)
        {
            result=pthread_mutex_lock(&(ser->mutex_x));
            if(0==result)
            {
                printf("waiting for the mutex \n");
            }            
            result=pthread_cond_wait(&(ser->cond_t),&(ser->mutex_x));    
            if(ser->state!=IDLE)
                goto End;
                
            printf("the conditions has been notified\n");
            //we take this thread to busy list
            ser->m_pool->AddtoIdle(false,ser);
            ser->m_pool->Addtobusy(true,ser);
            // really   work
            
            DoSomething:
            ser->state=WORKING;            
            printf("Do Something...\n");
            ser->DoJob();
            ser->Complete();//this function change state
            End:
            pthread_mutex_unlock(&(ser->mutex_x));                    
        }
    }
    return NULL;
}
void Servant::stop()
{
    if(state==IDLE)        
    {
        m_pool->AddtoIdle(false,this);
        m_pool->Addtostop(true,this);
        state=STOP;
        printf("thread stop!\n");        
    }
    else if(state==WORKING)
    {
        printf("current state is WORKING stop failed!\n");                
    }
    else if(state==STOP)
    {
        printf("thread already stopped!\n");                
    }
    else 
    {
        printf("sorry unknown state!\n");
        state=STOP;
    }
}
void Servant::wakeup()
{
    if(state==STOP)        
    {
        m_pool->Addtostop(false,this);
        m_pool->AddtoIdle(true,this);
        state=IDLE;    
        printf("thread wakeup!\n");            
    }
    else if(state==WORKING)
    {
        printf("current state  is WORKING stop failed!\n");
    }
    else if(state==IDLE)
    {
        printf("current state  is idle never need wakeup!\n");
    }
    else
    {
        printf("sorry unknown state..\n");
        state=IDLE;
    }
}
void Servant::Complete()//完成操作
{
    //完成任务，该线程变为idle        
    m_pool->Addtobusy(false,this);
    m_pool->AddtoIdle(true,this);    
    state=IDLE;
}
void Servant::join()
{
    pthread_join(m_tid,NULL);
}
void Servant::notify()
{
    if(state==IDLE)
    {        
        printf("we have notified thread running\n");
        pthread_cond_signal(&cond_t);    
    }
    else
    {
        printf("sorry ,the signal is not correct\n");
    }
}
void Servant::exit()
{
    state=EXIT;
    pthread_cond_signal(&cond_t);    
}




void ServantPool::StopAll()
{    
    vector<Servant*>::iterator itr=m_idle_list.begin();    
    for(;itr!=m_idle_list.end();)
    {
        (*itr)->stop();        
    }
    itr=m_busy_list.begin();
    for(;itr!=m_busy_list.end();)
    {
        (*itr)->stop();        
    }    
}
void ServantPool::create(int num)
{
    int i=0;
    for(;i<num;i++)
    {
        Servant* tmp=new Servant(this);
        m_idle_list.push_back(tmp);
    }
}
void ServantPool::AddtoIdle(bool add,Servant* ser)
{
    if(add)
    {
        // add ser to idle list
        pthread_mutex_lock(&vec_mutex);
        m_idle_list.push_back(ser);
        pthread_mutex_unlock(&vec_mutex);
    }
    else
    {
        // del ser from idle list
        pthread_mutex_lock(&vec_mutex);
        vector<Servant*>::iterator itr=m_idle_list.begin();
        for(;itr!=m_idle_list.end();itr++)
        {
            if(*itr==ser)
            {
                m_idle_list.erase(itr);
                break;
            }
        }
        pthread_mutex_unlock(&vec_mutex);
    }
}
void ServantPool::Addtobusy(bool add,Servant* ser)
{
    if(add)
    {
        // add ser to idle list
        pthread_mutex_lock(&vec_mutex);
        m_busy_list.push_back(ser);
        pthread_mutex_unlock(&vec_mutex);
    }
    else
    {
        // del ser from idle list
        pthread_mutex_lock(&vec_mutex);
        vector<Servant*>::iterator itr=m_busy_list.begin();
        for(;itr!=m_busy_list.end();itr++)
        {
            if(*itr==ser)
            {
                m_busy_list.erase(itr);
                break;
            }
        }
        pthread_mutex_unlock(&vec_mutex);
    }
}
void ServantPool::Addtostop(bool add,Servant* ser)
{
    if(add)
    {
        // add ser to idle list
        pthread_mutex_lock(&vec_mutex);
        m_stop_list.push_back(ser);
        pthread_mutex_unlock(&vec_mutex);
    }
    else
    {
        // del ser from idle list
        pthread_mutex_lock(&vec_mutex);
        vector<Servant*>::iterator itr=m_stop_list.begin();
        for(;itr!=m_stop_list.end();itr++)
        {
            if(*itr==ser)
            {
                m_stop_list.erase(itr);
                break;
            }
        }
        pthread_mutex_unlock(&vec_mutex);
    }
}
void ServantPool::startAll()
{
    int i=0;
    for(;i<m_idle_list.size();i++)
    {
        Servant* tmp=m_idle_list[i];
        printf("start the thread %d\n",i);
        tmp->start();//create the thread
    }
}

void ServantPool::stop(Servant* id)
{    
    vector<Servant*>::iterator itr=m_idle_list.begin();    
    for(;itr!=m_idle_list.end();itr++)
    {
        if((*itr)==id)
        {    
            (*itr)->stop();            
            return;
        }
    }
}

void ServantPool::waitforAll()
{
    int i=0;
    int nums=m_busy_list.size();
    for(;i<nums;i++)
    {            
        Servant* tmp=m_busy_list[i];
        tmp->join();
    }
    nums=m_idle_list.size();
    i=0;
    for(;i<nums;i++)
    {            
        Servant* tmp=m_idle_list[i];
        tmp->join();
    }    
}

void ServantPool::wakeup(Servant* id)
{    
    vector<Servant*>::iterator itr=m_busy_list.begin();    
    for(;itr!=m_busy_list.end();itr++)
    {
        if((*itr)==id)
        {    
            (*itr)->wakeup();            
            return;
        }
    }
}
ServantPool * ServantPool::hInstance=NULL;
ServantPool * ServantPool::getInstance()
{    
    if(NULL==hInstance)
    {
        hInstance=new ServantPool();
        pthread_mutex_init(&vec_mutex,NULL);
    }
    return hInstance;        
}
ServantPool::~ServantPool()
{
    vector<Servant*>::iterator itr=m_idle_list.begin();
    for(;itr!=m_idle_list.end();)
    {        
        (*itr)->exit();                
        delete *itr;        
        itr=m_idle_list.erase(itr);        
    }
    
    itr=m_busy_list.begin();
    for(;itr!=m_busy_list.end();)
    {        
        (*itr)->exit();                
        delete *itr;        
        itr=m_busy_list.erase(itr);        
    }    
    
    itr=m_stop_list.begin();
    for(;itr!=m_stop_list.end();)
    {        
        (*itr)->exit();                
        delete *itr;        
        itr=m_stop_list.erase(itr);        
    }    
}
Servant* ServantPool::Accepting()
{
    if(m_idle_list.size()>0)
    {
        return m_idle_list[0];
    }
    return NULL;
}

main.c文件如下： 

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<pthread.h>
#include"Servant.h"
//create 100 servants thread
#define SERVANT_NUM 1
int main()
{

	ServantPool *mm=ServantPool::getInstance();
	printf("we begin create %d Servant threads \n",SERVANT_NUM);
	mm->create(SERVANT_NUM);
	mm->start();
	mm->waitforAll();
	return 0;
}

makefile文件内容如下： 

test:Servant.o main.o
	g++ -o   test Servant.o main.o  -lpthread
Servant.o:Servant.cpp Servant.h
	g++ -g -c  Servant.cpp -lpthread
main.o:main.c Servant.h   
	g++ -g -c  main.c -lpthread
clean:
	rm *.o test

这里面需要注意一点，就是，在修改线程状态时，首先应该修改的是线程状态值，然后才继续进行信号通知，这样可以避免，当信号通知时，状态值还没有发生变化！！！

信号修改失败。好了，这就是暂时要表达的线程池的内容了，如有错误，该请大神指正


世纪殇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Linux C++ 服务器之线程池 C++11
11-09
基于Linux平台，C++开发，socket服务器之线程池，使用thread，同步利用mutex和condition_variable实现
c++代码实现一个线程池（清晰明了，一看就懂）
最新发布
qq_40989769的博客
06-02 1517
最后说一说usable，当我们销毁线程池的时候，设置每一个线程的usable为false，那么不会立刻中断每个线程正在执行的回调，而是等回调结束后，在下一次循环中如果检测到usable为false后，就会退出整个大循环，并释放自己的锁，唤醒线程池其它休眠的线程。获取（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等），免费分享。
linux下实现一个C++线程池
weixin_45157276的博客
08-25 1080
C++练手，在linux环境下实现一个线程池
Linux - C++实现简单线程池
TPON的博客
03-09 633
Linux下，用C++实现简单线程池。线程安全的单例模式
Linux中基于c/c++多线程编程学习杂记：c语言手写线程池
m0_68731112的博客
05-23 274
文章转载自爱编程的大丙
linux下c++线程池
11-20
一个简单好用的线程池，包括如何使用的demo，未考虑动态伸缩。 之前上传的那些线程池资源都不及这个。 用qtcreator可以直接打开。
LINUX_c++线程池
11-06
LINUX_c++线程池的一本书，讲解线程池的技术。
简单linux C++线程池
01-29
简单linux C++线程池实现 vector存储任务，封装类实现线程池功能。新手学习线程池的好机会，Makefile编译可直接运行。
Linux c++ 线程池的实现
03-06
Linux下的c++的线程池实现，包括线程间的同步
Linux C/C++ 开发（学习笔记五）：线程池
菊头蝙蝠的博客
03-07 804
Linux C/C++ 开发（学习笔记五）：线程池一、线程池的由来和组成二、 一、线程池的由来和组成 如果涉及到十万个we线程，根本没办法开这么多 如果一个poxis线程占8M内存，那么16G内存也只能有2048个线程，根本没法满足十万线程的需求。 线程池 1.避免线程太多，使得内存耗尽 2.避免创建与销毁线程的代价 3.任务与执行分离 所以需要 任务与执行 分离。 一个例子，对于营业厅来说，办理业务的人是任务队列，柜员 是执行队列 因此需要一个组件（也就是线程池），使得任务队列和执行队列，正常有序
linux C++ 实现线程池（避免线程创建的耗时）
05-22
linux下c++写的线程池，可以了解pthread_cond_timewait和pthread_detach的用法，自定义最大使用的线程数量，线程退出线程池的超时时间，任务优先级处理。
Linux 线程池 C++
08-03
在Linux下做的一个完全抽象的基于c++语言的线程池
C/C++ linux下具备功能的线程池，拿来就可以用
08-29
一个写好的线程池类，拿去就可以使用！
linux 线程池源码 c++版
03-07
这是一个很好很稳定的线程池源码，我自己项目中使用的，跑的很稳定，也很好扩展
c++ 实现的线程池（linux环境下）
01-14
c++ 实现的线程池（linux环境下），大家一块学习，共同进步。
Linux C++线程池
weixin_30247307的博客
06-29 101
1、为什么需要线程池？ 部分应用程序需要执行很多细小的任务，对于每个任务都创建一个线程来完成，任务完成后销毁线程，而这就会产生一个问题：当执行的任务所需要的时间T1小于等于创建线程时间T2和销毁线程时间T3总和时即T1 <= T2 + T3，应用处理任务的响应能力会大大减弱，从而影响了应用程序性能，为了解决这类问题，线程池技术提供了很好的解决方案。线程池顾名思义就是把线程资源池化，...
Linux下C++实现线程池
qq_39107832的博客
08-03 831
线程池原理 我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题：如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。 那么有没有一种办法使得线程可以复用，就是执行完一个任务，并不被销毁，而是可以继续执行其他的任务呢？ 线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建 线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处
线程池讲解（C++）|LinuxC/C++服务器开发
C/C++Linux、音视频、DPDK
05-21 563
1. 前言 线程池是一般服务端或者客户端编程经常要用到的一种管理线程的类，从网上找到一个比较好的线程池实现，主要运用C++11。记录一下理解过程，帮助学习线程池和C++11。 150行代码手写线程池 ：https://www.bilibili.com/video/BV1yQ4y1o7zv/ 2. 代码 2.1 先上代码 threadPool.hpp /* * @Author WangYubo * @Date 09/17/2018 * @Description 线程池实现的头文件 */ #ifnd
linux下 c++实现 线程池——同步异步
weixin_43892561的博客
11-04 640
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、线程池的结构二、代码示例前置数据结构2.读入数据总结 前言 我的技术栈都是在windows积累，然而c++后端开发主要是在Linux平台，这是对我的技术栈的一个迁移。 一、线程池的结构 1. 一条线程安全的任务队列，负责为线程分配任务。 2. 一个线程管理类 handler，负责连接线程池与任务队列； 3. job struct 4. job_list记录 本质上通过一条任务队列的入队出队，为线程池中的空闲线程分配任
linux 线程池实现快速排序c++
04-28
以下是一个简单的基于线程池的快速排序实现，使用了 pthread 库和 C++11 的标准库： ```c++ #include <iostream> #include <vector> #include <queue> #include <thread> #include <mutex> #include <condition_variable> std::mutex mtx; std::condition_variable cv; std::queue<std::function<void()>> tasks; std::vector<std::thread> threads; void sort(std::vector<int>& v, int left, int right) { if (left < right) { int pivot = v[left]; int i = left + 1; int j = right; while (i <= j) { if (v[i] <= pivot) { ++i; } else if (v[j] > pivot) { --j; } else { std::swap(v[i], v[j]); } } std::swap(v[left], v[j]); sort(v, left, j - 1); sort(v, j + 1, right); } } void worker() { while (true) { std::function<void()> task; { std::unique_lock<std::mutex> lock(mtx); cv.wait(lock, []{ return !tasks.empty(); }); task = tasks.front(); tasks.pop(); } task(); } } int main() { const int num_threads = 4; for (int i = 0; i < num_threads; ++i) { threads.emplace_back(worker); } std::vector<int> v = {4, 6, 2, 8, 5, 7, 1, 9, 3}; int n = v.size(); std::function<void()> task = [&]{ sort(v, 0, n - 1); }; { std::unique_lock<std::mutex> lock(mtx); tasks.emplace(task); } cv.notify_one(); for (auto& t : threads) { t.join(); } for (int x : v) { std::cout << x << " "; } std::cout << std::endl; return 0; } ``` 该程序中，我们首先定义了一个线程池，使用了一个条件变量 cv 和一个互斥锁 mtx 来实现线程间的同步和通信。 然后定义了一个 worker 函数，该函数会不断从任务队列中取出任务并执行，直到程序结束。 在主函数中，我们创建了 num_threads 个线程，并将它们的执行函数设置为 worker。然后创建了一个需要排序的数组 v，并定义了一个任务 task，该任务将对数组进行快速排序。 接着，我们将任务加入到任务队列中，并使用条件变量 cv 来通知一个线程可以开始执行任务了。由于我们只有一个任务，因此只需要通知一个线程即可。 最后，我们等待所有线程执行完毕，输出排序后的数组。 注意这里的实现使用了 C++11 的标准库，如果你使用的是 C 语言，可以使用类似的 POSIX 线程库来实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

世纪殇

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值