【linux】基于单例模式实现线程池

一、线程池

1.1 池化的概念

当我们处理任务的时候，一般就是来一个任务我们就创建一个线程来处理这个任务。这里首先的一个问题就是效率会降低（创建线程需要成本）。

接下来我们可以类比STL的扩容机制，当我们使用vector申请扩容的时候，就算我们只多申请一块空间，它也会给我们直接按照扩容机制给我们多扩容1.5倍或两倍，这样当我们后边还想扩容的时候就不用申请资源了。

而我们可以借助这种思想，我们先创建一批线程，当任务队列里面没任务时，每个线程都先休眠，一旦任务队列来了任务，就会唤醒线程来处理。
唤醒一个线程的成本要比创建一个线程的成本要小。

而我们把这个模型就叫做线程池。

1.2 线程池的实现

先把之前对原生线程库封装的组件引入，再做一些小小的调整。

// mythread.hpp
#pragma once

#include <iostream>
#include <pthread.h>
#include <cstring>
#include <string>
#include <cassert>
#include <functional>
#include <unistd.h>

class Thread
{
   
   
    typedef std::function<void*(void*)> func_t;
private:
    // 不加static就会有this指针
    static void* start_routine(void* args)
    {
   
   
        //return _func(args);
        // 无this指针，无法调用
        Thread* pct = static_cast<Thread*>(args);
        pct->_func(pct->_args);
        return nullptr;
    }
public:
    Thread(func_t fun, void* args = nullptr)
        : _func(fun)
        , _args(args)
    {
   
   
        char buf[64];
        snprintf(buf, sizeof buf, "thread-%d", _number++);
        _name = buf;
    }

    void start()
    {
   
   
        // int n = pthread_create(&_tid, nullptr, _func, _args);
        // _func是C++函数，pthread_create是C接口，不能混编
        int n = pthread_create(&_tid, nullptr, start_routine, this);
        assert(n == 0);
        (void)n;
    }

    std::string GetName()
    {
   
   
        return _name;
    }

    void join()
    {
   
   
        int n = pthread_join(_tid, nullptr);
        assert(n == 0);
        (void)n;
    }
private:
    std::string _name;// 线程名
    pthread_t _tid;// 线程id
    func_t _func;// 调用方法
    void *_args;// 参数
    static int _number;// 线程编号
};

int Thread::_number = 1;


// Main.cc
#include "mythread.hpp"

using std::cout;
using std::endl;

void* threadhandler(void* args)
{
   
   
    std::string ret = static_cast<const char*>(args);
    while(true)
    {
   
   
        cout << ret << endl;
        sleep(1);
    }
}

int main()
{
   
   
    Thread t1(threadhandler, (void*)"thead1");
    Thread t2(threadhandler, (void*)"thead2");
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    return 0;
}

验证过没有问题以后就可以实现线程池创建一批线程。

既然需要多个线程访问这个任务队列，那么就需要用锁来保护资源，而我们直接可以把之前写过的锁的小组件引入进来：

// mymutex.hpp
#pragma once
#include <iostream>
#include <pthread.h>

class Mutex 
{
   
   
public:
    Mutex(pthread_mutex_t* plock = nullptr)
        : _plock(plock)
    {
   
   }

    void lock()
    {
   
   
        // 被设置过
        if(_plock)
        {
   
   
            pthread_mutex_lock(_plock);
        }
    }

    void unlock()
    {
   
   
        if(_plock)
        {
   
   
            pthread_mutex_unlock(_plock);
        }
    }
private:
    pthread_mutex_t *_plock;
};

// 自动加锁解锁
class LockAuto
{
   
   
public:
    LockAuto(pthread_mutex_t *plock)
        : _mutex(plock)
    {
   
   
        _mutex.lock();
    }

    ~LockAuto()
    {
   
   
        _mutex.unlock();
    }
private:
    Mutex _mutex;
};

在创建一批线程的时候，我们要实现线程的运行函数，因为是要传给Thread类里面的_func中，所以不能有this指针，必须是静态成员函数。但是设置成静态成员函数的时候，就没有this指针，无法访问成员变量（锁和任务队列等），所以我们要封装这些接口。

template <class T>
class ThreadPool
{
   
   
private:
    static void* handlerTask(void