Linux组件封装(七)——线程池的简单封装

线程池的封装，基础思想与生产者消费者的封装一样，只不过我们是将线程池封装为自动获取任务、执行任务，让用户调用相应的接口来添加任务。

在线程池的封装中，我们同样需要用到的是MutexLock、Condition、Thread这些基本的封装。

基础封装如下:

MutexLock:

#ifndef MUTEXLOCK_H
#define MUTEXLOCK_H

#include "NonCopyable.h"
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#define TINY_CHECK(exp)
        if(!exp)
        {    
            fprintf(stderr, "File : %s, Line : %d Exp : ["#exp"] is true, abort.
", __FILE__, __LINE__); abort();
        }



class MutexLock :  NonCopyable
{
    friend class Condition;
public:
    MutexLock();
    ~MutexLock();
    void lock();
    void unlock();

    bool isLocked() const { return _isLock; }
    pthread_mutex_t *getMutexPtr() { return &_mutex; }

private:
    void restoreMutexStatus()
    { _isLock = true; }

    pthread_mutex_t _mutex;
    bool _isLock;
};


class MutexLockGuard : NonCopyable            //将锁封装到MutexLockGuard中，
{                                            //这样只需定义一个对象，便可
public:                                        //便可自动上锁，对象销毁时自动解锁
    MutexLockGuard(MutexLock &mutex)
        :_mutex(mutex)
    { _mutex.lock(); }

    ~MutexLockGuard()
    { _mutex.unlock(); }

private:
    MutexLock &_mutex;
};
#define MutexLockGuard(m) "ERROR"

#endif

#include "MutexLock.h"
#include <assert.h>

MutexLock::MutexLock()
    :_isLock(false)
{
    TINY_CHECK(!pthread_mutex_init(&_mutex, NULL));
}

MutexLock::~MutexLock()
{
    assert(!isLocked());
    TINY_CHECK(!pthread_mutex_destroy(&_mutex));
}

void MutexLock::lock()
{
    TINY_CHECK(!pthread_mutex_lock(&_mutex));
    _isLock = true;
}

void MutexLock::unlock()
{
    _isLock = false;
    TINY_CHECK(!pthread_mutex_unlock(&_mutex));
}

Condition:

#ifndef CONDITION_H
#define CONDITION_H

#include <pthread.h>
#include "NonCopyable.h"

class MutexLock;


class Condition : NonCopyable
{
public:
    Condition(MutexLock &mutex);
    ~Condition();

    void wait();
    void notify();
    void notifyAll();
private:
    pthread_cond_t _cond;
    MutexLock &_mutex;
};

#endif

#include "Condition.h"
#include "MutexLock.h"
#include <assert.h>

Condition::Condition(MutexLock &mutex)
    :_mutex(mutex)
{
    TINY_CHECK(!pthread_cond_init(&_cond, NULL));
}

Condition::~Condition()
{
    TINY_CHECK(!pthread_cond_destroy(&_cond));
}

void Condition::wait()
{
    assert(_mutex.isLocked());
    TINY_CHECK(!pthread_cond_wait(&_cond, _mutex.getMutexPtr()));
    _mutex.restoreMutexStatus();
}

void Condition::notify()
{
    TINY_CHECK(!pthread_cond_signal(&_cond));
}

void Condition::notifyAll()
{
    TINY_CHECK(!pthread_cond_broadcast(&_cond));
}

Thread:

#ifndef THREAD_H
#define THREAD_H
#include <boost/noncopyable.hpp>
#include <functional>
#include <pthread.h>
class Thread : boost::noncopyable
{
public:

    typedef std::function<void()> ThreadCallback;

    Thread(ThreadCallback cb);
    ~Thread();

    void start();
    void join();




private:

    static void *runInThread(void *);
    pthread_t _threadId;
    bool _isRun;
    ThreadCallback _callback;
};


#endif  /*THREAD_H*/

#include "Thread.h"
#include <assert.h>

Thread::Thread(ThreadCallback cb)
    :_threadId(0),
     _isRun(false),
     _callback(cb)
{

}

Thread::~Thread()
{
    if(_isRun)
        pthread_detach(_threadId);
}


void Thread::start()
{
    pthread_create(&_threadId, NULL, runInThread, this);
    _isRun = true;
}

void Thread::join()
{
    assert(_isRun);
    pthread_join(_threadId, NULL);
    _isRun = false;
}

void *Thread::runInThread(void *arg)
{
    Thread *p = static_cast<Thread *>(arg);
    p->_callback();
    return NULL;
}

NonCopyable:

#ifndef NONCOPYABLE_H
#define NONCOPYABLE_H

class NonCopyable             //禁用值语意
{
    public:
        NonCopyable() { }
        ~NonCopyable() { }
    private:
        NonCopyable(const NonCopyable &);
        void operator= (const NonCopyable &);
};

#endif  /*NON_COPYABLE_H*/

在线程池的封装中，我们需要的数据结构有一个互斥锁，两个条件变量，任务队列以及线程池的队列。

然后，我们需要提供给用户添加任务的接口addTask，在线程池中，我们需要相应的获取任务函数getTask，执行任务的函数runInThread。

头文件代码如下:

#ifndef THREAD_POOL_H
#define THREAD_POOL_H

#include <boost/noncopyable.hpp>
#include "MutexLock.h"
#include "Condition.h"
#include <queue>
#include <memory>
#include <functional>

class Thread;

class ThreadPool : boost::noncopyable
{
public:
    typedef std::function<void()> Task;

    ThreadPool(size_t queueSize, size_t poolSize);
    ~ThreadPool();

    void start();
    void stop();

    void addTask(Task task);
    bool isRunning() const
    { return _isStart; }

private:
    Task getTask();
    void runInThread();

    mutable MutexLock _mutex;
    Condition _full;
    Condition _empty;
    size_t _queueSize;
    std::queue<Task> _queue;
    const size_t _poolSize;
    std::vector<std::unique_ptr<Thread> > _threads;
    bool _isStart;
};


#endif  /*THREAD_POOL_H*/

在构造函数中，我们用一把锁去初始化两个条件变量，用相应的长度来初始化任务队列的长度与线程池中线程的个数:

ThreadPool::ThreadPool(size_t queueSize, size_t poolSize)
    :_full(_mutex),
     _empty(_mutex),
     _queueSize(queueSize),
     _poolSize(poolSize),
     _isStart(false)
{

}

addTask函数中，我们首先要判断线程池是否开启，然后加锁，判断任务队列是否已满，进行等待。等待后将相应的任务加入到任务队列，通知getTask来获取任务:

void ThreadPool::addTask(Task task)
{
    if(!_isStart)
        return;
    MutexLockGuard lock(_mutex);
    while(_queue.size() >= _queueSize)
        _empty.wait();

    _queue.push(std::move(task));
    _full.notify();
}

getTask函数中，我们首先判断线程池是否开启，然后对应加锁，判断任务队列是否为空，进行等待。等待后，取出任务队列中的第一个任务，通知addTask可以继续添加任务:

ThreadPool::Task ThreadPool::getTask()
{
    if(!_isStart)
        return Task();
    
    MutexLockGuard lock(_mutex);
    while(_queue.empty() && _isStart)
        _full.wait();



    assert(!_queue.empty());
    Task task = _queue.front();
    _queue.pop();
    _empty.notify();

    return task;
}

runInThread函数相对简单，只是获取相应任务，执行该任务即可:

void ThreadPool::runInThread()
{
    while(_isStart)
    {
        Task task(getTask());
        if(task)
            task();
    }
}

start函数，相对来说就比较复杂，我们首先需要new出线程，将线程添加到线程队列，然后将线程队列中的线程开启。

void ThreadPool::start()
{
    if(_isStart)
        return ;
    _isStart = true;

    for(size_t i = 0; i != _poolSize; ++ i)
        _threads.push_back(std::unique_ptr<Thread>(new Thread(std::bind(&ThreadPool::runInThread, this))));

    for(size_t i = 0; i != _poolSize; ++ i)
        _threads[i]->start();
}

这里需要注意:由于线程不可复制和赋值，我们将Thread相应的unique_ptr添加到线程队列，才可以达到相应的效果。而每个线程的回调函数，我们运用C++11的特性——function和bind来实现，我们将Thread的回调函数设置为一个function模板，通过bind，将ThreaPool::runInThread函数中的一个隐式参数转化为无参数，即将this指针绑定给ThreaPool::runInThread，这样，ThreaPool::runInThread就不再需要this指针了。

stop函数，我们需要考虑的因素较多，由于线程池已经开启，但不是每个线程都在运行，有些还在沉睡中，所以我们需要通过notifyAll来通知所有的线程获取任务，这样线程池中的线程已经唤醒，然后我们对每个线程进行join，而任务队列中未执行的任务，我们需要将其清空，通过pop函数来弹出任务队列中的任务:

void ThreadPool::stop()
{
    if(!_isStart)
        return ;
    {
        MutexLockGuard lock(_mutex);
        _isStart = false;
        _full.notifyAll();
    }

    for(size_t i = 0; i != _poolSize; ++ i)
        _threads[i]->join();

    while(!_queue.empty())
        _queue.pop();

    _threads.clear();
}

具体实现代码如下:

#include "Thread.h"
#include "ThreadPool.h"
#include <assert.h>
using namespace std;

ThreadPool::ThreadPool(size_t queueSize, size_t poolSize)
    :_full(_mutex),
     _empty(_mutex),
     _queueSize(queueSize),
     _poolSize(poolSize),
     _isStart(false)
{

}
ThreadPool::~ThreadPool()
{
    if(_isStart)
        stop();
}

void ThreadPool::addTask(Task task)
{
    if(!_isStart)
        return;
    MutexLockGuard lock(_mutex);
    while(_queue.size() >= _queueSize)
        _empty.wait();

    _queue.push(std::move(task));
    _full.notify();
}

ThreadPool::Task ThreadPool::getTask()
{
    MutexLockGuard lock(_mutex);
    while(_queue.empty() && _isStart)
        _full.wait();

    if(!_isStart)
        return Task();

    assert(!_queue.empty());
    Task task = _queue.front();
    _queue.pop();
    _empty.notify();

    return task;
}

void ThreadPool::runInThread()
{
    while(_isStart)
    {
        Task task(getTask());
        if(task)
            task();
    }
}
void ThreadPool::start()
{
    if(_isStart)
        return ;
    _isStart = true;

    for(size_t i = 0; i != _poolSize; ++ i)
        _threads.push_back(std::unique_ptr<Thread>(new Thread(std::bind(&ThreadPool::runInThread, this))));

    for(size_t i = 0; i != _poolSize; ++ i)
        _threads[i]->start();
}

void ThreadPool::stop()
{
    if(!_isStart)
        return ;
    {
        MutexLockGuard lock(_mutex);
        _isStart = false;
        _full.notifyAll();
    }

    for(size_t i = 0; i != _poolSize; ++ i)
        _threads[i]->join();

    while(!_queue.empty())
        _queue.pop();

    _threads.clear();
}

在测试中，我们可以通过前面的定时器来测试，生成一个定时器线程，定时器到期时，对线程池执行stop。

测试代码如下:

#include "ThreadPool.h"
#include "nano_sleep.hpp"
#include <iostream>
#include <time.h>
#include "TimerThread.h"
using namespace std;

void foo()
{
    cout << rand() % 100 << endl;
}
void stopPool(ThreadPool *a)
{
    a->stop();
}
void nano_sleep(double val);
int main(int argc, const char *argv[])
{
    ThreadPool b(120, 4);
    TimerThread a(4, 0, std::bind(&stopPool, &b));
    b.start();
    a.start();
    while(b.isRunning())
    {
        b.addTask(&foo);
        nano_sleep(0.5);
    }

    a.stop();

    return 0;
}

void nano_sleep(double val)
{
    struct timespec tv;
    tv.tv_sec = val; //取整
    tv.tv_nsec = (val - tv.tv_sec) * 1000 * 1000 * 1000;

    int ret;
    do
    {
        ret = nanosleep(&tv, &tv);
    }while(ret == -1 && errno == EINTR);
}

在测试代码中，nano_sleep是一个相对精确地睡眠函数，我们可以将睡眠的精度限制到double。

当定时器到时后，会显示timeout，程序会自动退出。

注意:由于运用了C++11的一些特性，如function、bind和右值引用等，编译时需加上-std=c++0x