c++线程池

用linux下的系统函数封装了个简单线程池，需要添加新任务时，继承ITask实现自己的run方法，然后add到线程池即可。

main.cpp

#include "threadPool.h"
#include <iostream>
#include <unistd.h>
using namespace std;


class MyTask: public ITask{
public:
    MyTask() = default;
    ~MyTask(){};
    void run(){//实现自己的run方法
        cout<<"id =  "<<m_id<<endl;
        sleep(1);
        return;
    }
};

int main(){
    ThreadPool threadPool(5);
    for(int i = 0; i < 10; i++){
        MyTask *task = new MyTask();
        task->setId(i);
        threadPool.addTask(task);
    }
    cout<<"add task end"<<endl;
    sleep(4);
    threadPool.stopAll();
    return 0;
};

threadpool.cpp

#include "threadPool.h"
#include <iostream>
using namespace std;

void* ThreadFunc(void* data){
    ThreadPool *threadPool = (ThreadPool*)data;
    pthread_t threadId = pthread_self();
    while(1){

        pthread_mutex_lock(&threadPool->m_pthreadMutex);
        if(threadPool->m_shutDown){
            printf("tid: %lu exit\n", pthread_self());
            pthread_mutex_unlock(&threadPool->m_pthreadMutex);
            //pthread_exit(nullptr);
            break;
        }

        while(threadPool->m_TaskList.empty() && !threadPool->m_shutDown){
            pthread_cond_wait(&threadPool->m_pthreadCond, &threadPool->m_pthreadMutex);
        }
        
        if(!threadPool->m_TaskList.empty()){
            ITask* Task = threadPool->m_TaskList.front();
            threadPool->m_TaskList.pop();
            pthread_mutex_unlock(&threadPool->m_pthreadMutex);
            printf("tid: %lu do task\n", threadId);
            if(nullptr != Task){
                Task->run();
                delete Task;
            }    
        }
        else{
            pthread_mutex_unlock(&threadPool->m_pthreadMutex);
        }
        
    }
    return (void*)0;
};

void ThreadPool::createThread(){
    m_ptPthread = new pthread_t[m_threadNum];
    for(int i = 0; i < m_threadNum; i++){
        pthread_create(&m_ptPthread[i], nullptr, ThreadFunc, (void *)this);
    }
    return;
};

void ThreadPool::stopAll(){

    if(m_shutDown) return ;

    cout<<"stop all thread"<<endl;
    m_shutDown = true;
    pthread_cond_broadcast(&m_pthreadCond);
    for(int i = 0; i < m_threadNum; i++){
        pthread_join(m_ptPthread[i], NULL);
    }
    return;
}

void ThreadPool::addTask(ITask* task){
    pthread_mutex_lock(&m_pthreadMutex);
    m_TaskList.push(task);
    pthread_mutex_unlock(&m_pthreadMutex);
    pthread_cond_signal(&m_pthreadCond);
    return;
}

threadPool.h

#ifndef _THREAD_POOL_H
#define _THREAD_POOL_H
#include<queue>
#include<string>
#include<pthread.h>
using namespace std;

class ITask{
public:
    ITask(){};
    ITask(string& strTaskName): m_strTaskName(strTaskName), m_id(0){};
    virtual ~ITask(){};
    void setId(int id){
        m_id = id;
	};
    virtual void run() = 0;
protected:
    string m_strTaskName;
    int m_id;
};


class ThreadPool{
public:
    ThreadPool(int ithreadNum): m_threadNum(ithreadNum){
        m_shutDown = false;
        m_pthreadMutex = PTHREAD_MUTEX_INITIALIZER;
        m_pthreadCond = PTHREAD_COND_INITIALIZER;
        createThread();
    };
    ~ThreadPool(){
        if(nullptr != m_ptPthread)
            delete[] m_ptPthread;
        m_ptPthread = nullptr;
        pthread_mutex_destroy(&m_pthreadMutex);
        pthread_cond_destroy(&m_pthreadCond);
        while(!m_TaskList.empty()){
            ITask *taskTmp = m_TaskList.front();
            m_TaskList.pop();
            delete taskTmp;
        }
    };
    void addTask(ITask* task);
    void stopAll();

private:
    int m_threadNum;
    bool m_shutDown;
    queue<ITask*> m_TaskList;
    pthread_t* m_ptPthread;
    pthread_mutex_t m_pthreadMutex;
    pthread_cond_t m_pthreadCond;
protected:
    void createThread();
    friend void* ThreadFunc(void* threadData);
};
#endif

cc = g++
prom = calc
deps = $(shell find ./ -name "*.h")
src = $(shell find ./ -name "*.cpp")
obj = $(src:%.c=%.o)

$(prom): $(obj)
	$(cc)  -std=c++11 -o  $(prom) $(obj)  -lpthread

%.o: %.c $(deps)
	$(cc) -c $< -o $@

clean:
	rm -rf $(obj) $(prom)