手写线程池-第一版

线程池是什么

举个例子，在以前文章又提到过 好几种reactor模式

可以大概分为这几种

单 Reactor 单进程 / 线程： **接收数据 –> 解析数据 –> 发送数据 **

单 Reactor 多线程 ： 接收数据 –> fd 交给线程 –> 线程全程处理

​ 接收数据 –> 从fd中抽出数据 –> 数据交给线程

如果接收一次数据，创建一次线程处理完后又销毁线程，这样太消耗cpu资源了,为了改善这个性能，可以先创建好一定数量的线程，线程处理饥渴的模式，有业务需要处理了，就派一个线程去处理，处理完后，又处于饥渴的转态，其实典型的空间换时间的问题，有很设计都是这样，如内存池（减少系统调用的次数），连接池等。

如何设计呢一个池呢？ 好像Java有现成的类可以调，这次用C++ 写一个线程池，第一次写，有很多东西没考虑到，以后继续迭代吧

看了一个视频，用c写线程池，大致理解了思路，于是自己 用 c++写一遍（ c with class …)

思路：

• 一个线程池类， 可以初始初始化线程 ，任务队列，锁
• 工作类， 一个线程对应个工作类，工作类从任务队列中抽取任务
• 任务类 ，产生一个任务 插入任务队列中
• 线程锁类， 用的还是 POSIX标准下的互斥锁，不过封装一遍（我看别人写的代码好多都是基本api在封装一遍的，所以我也尝试下）， 还有一个条件变量，没任务全部线程等待，有任务 发送信号，通知一个等待的线程获取任务

class pool{
	private:
		list<Job*> Jobs;  //用双向链表 存放任务  应该用队列比较好的
		mylocker *mutelock = new mylocker(); // 初始化一个锁
	public:
         //初始化线程
		pool(int maxNumber){   
			for(int i = 0; i < maxNumber; i++){
                Worker *work = new Worker(); //工作类  
                work->lock = mutelock;       //全部线程公用一个锁
                work->Jobs = &Jobs;          //任务队列包含    我想着尽量不要用到 全局的变量，全部归到一个类里面
                int ret = pthread_create(&work->tid, NULL, fun, (void *)work);  // 开启线程  还有传参，工作类传进去
                pthread_detach(work->tid);  //线程分离，脱离主程序

			}
		}
		void addjob(Job *job){ //添加一个任务
            mutelock->mutelock(); //此时还是需要锁 保持同步  
            if(job->state == run){ //添加了任务的转态，不是需要运行的就加进去  
                				  //这里做的不是很好，是不是应该分为待处理，马上处理的任务队列呢，以后在补充
                cout << "添加队列中" << endl;
                Jobs.push_back(job);
                mutelock->condsignal();  //通知线程
            }
            mutelock->muteunlock(); 
		}
        int jobSize(){
            return Jobs.size();
        }
		~pool(){
            delete(mutelock);
		}
};

//任务类
class Job{
    public:
        int state = run;
        int data;
        void (*job_function)(int fd);  // 这里 添加个回调函数，可以自定义 要怎样的任务类

    public:
        Job(){
			//这里初始化
        }
        void runFun(){
            job_function(data);
        }
};

void *fun(void *arg){    
    //cout << "创建成功 " << pthread_self() << endl;  
    Worker *work = (Worker *)arg;  //参数类型转换   这个arg参数太好用了！
    while (1){
        work->lock->mutelock();    //条件变量需要 互斥锁
        // cout << "原地待命，等通知" << endl;
        // 队列空的话 等待等通知
        while (work->Jobs->empty()){  
            cout << "等待任务队列 " << work->Jobs->empty() << endl; 
            work->lock->condwait();
        }
        //走到这说明有任务了，此时还是锁的转态可以保持线程同步
        if(work->getTer() == 1){
            pthread_exit(NULL);
        }
        //从任务队列中 抽一个任务
        Job *job = work->Jobs->front();
        //pop掉任务
        work->Jobs->pop_front();
        work->lock->muteunlock();
        //此时解锁，因为我已经拿到任务里，应该不锁了，好像也不是很安全，如果是对处理的是共享的数据呢....
        cout << pthread_self() << "   data : ";
        job->runFun(); //线程运行任务的回调函数
        delete(job);      
    }
}

class Worker{
    private:
		int terminate;
	public:
		Worker(){
			terminate = 0;
		};
		int getTer(){
            return terminate;
        }
        void run(){

        }
	public:
	    pthread_t tid;  
        mylocker *lock;    
        list<Job*> *Jobs;


};

//封装 互斥锁 和 条件变量
class mylocker{
    private:
        pthread_mutex_t mutexlock;
		pthread_cond_t cond;
    public:
        mylocker(){
            mutexlock = PTHREAD_MUTEX_INITIALIZER;
			cond = PTHREAD_COND_INITIALIZER;
        }
        ~mylocker(){
            pthread_mutex_destroy(&mutexlock);
            pthread_cond_destroy(&cond);
        }
        bool mutelock(){
            return pthread_mutex_lock(&mutexlock) == 0;
        }
        bool muteunlock(){
            return pthread_mutex_unlock(&mutexlock) == 0;
        }
		bool condwait(){
			return pthread_cond_wait(&cond,&mutexlock);
		}
        bool condsignal(){
            return pthread_cond_signal(&cond);
        }
        pthread_mutex_t *get(){
            return &mutexlock;
        }    
};