---

前言

线程池主要是对之前内容的一个巩固，并且初步了解池化概念。

---

一、线程池是什么？

线程池就是提前开辟好一块空间，随时准备创造新线程来完成任务，可以理解为用空间来换时间，具体实现看以下示例代码。

二、示例代码

#include <pthread.h>
#include <cstdio>
#include <cstdlib>
#include "lockGuard.hpp"
#include "log.hpp"
const int default_ThreadNum = 5;
template <class T>
class ThreadPool
{

public:
    ThreadPool(int thread_num = default_ThreadNum)
    :_thread_num(thread_num)
    {
        pthread_mutex_init(&_mutex,nullptr);
        pthread_cond_init(&_cond,nullptr);
        for (int i = 1; i <= _thread_num; i++)
        {
            char nameBuffer[128];
            snprintf(nameBuffer, sizeof nameBuffer, "Thread %d", i);
            _threadPool.push_back(new Thread(nameBuffer, routine, (void *)this));
            logMessage(NORMAL, "%s 线程创建成功！", nameBuffer);
        }
    }

    bool isEmpty()
    {
        return _task_queue.empty();
    }

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

    pthread_mutex_t &getMutex()
    {
        return _mutex;
    }


    T getTask()
    {
        T task = _task_queue.front();
        _task_queue.pop();
        return task;
    }

    std::vector<Thread> &getpool()
    {
        return _threadPool;
    }

    static void *routine(void *args)
    {
        ThreadData *td = (ThreadData *)args;
        ThreadPool<T> *tp = (ThreadPool<T> *)td->_args;
        while (1)
        {
            T task;
            {
                lockGuard lg(&tp->getMutex());
                while (tp->isEmpty())
                    tp->waitCond();
                task = tp->getTask();
            }
            task(td->_name);
        }
    }

    void run()
    {
        for(auto& thread : _threadPool)
        {
            thread->start();
        }
    }

     void pushTask(const T &task)
     {
        lockGuard lg(&_mutex);
        _task_queue.push(task);
        pthread_cond_signal(&_cond);
     }

    ~ThreadPool()
    {
        for(auto& iter: _threadPool)
        {
            iter->join();
            delete iter;
        }
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond);
    }

private:
    int _thread_num;
    std::vector<Thread*> _threadPool;
    std::queue<T> _task_queue;

    pthread_mutex_t _mutex;
    pthread_cond_t _cond;
};

---