一个简单的线程池

线程池

当我们需要多次使用线程时，需要多次创建并销毁线程。而创建并销毁线程的过程势必会消耗内存。线程池是一种多线程处理形式，提前创建多个线程，处理过程中将任务添加到任务队列，每个线程不断往复的从任务队列中获取任务、执行任务。避免了在处理短时间任务时创建与销毁线程的代价。

应用场景：

1.需要大量的线程来完成任务，且完成任务的时间比较短。 WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大，你可以想象一个热门网站的点击次数。但对于长时间的任务，线程池的优点就不明显了。因为完成该任务时间可能比线程的创建时间大多了。

2.需要快速响应的需求。

3.突发性的大量需求，在没有线程池的情况下，将产生大量线程，而在短时间内产生大量线程可能会导致内存到达极限，出现错误。

在服务器使用一个线程来处理一个用户请求时，线程池可限制服务器中同时处理的用户数（等于线程池中线程总数）。

线程池示例：

1.创建固定数量线程的线程池，循环的从任务队列中获取任务对象；

2.获取到任务对象后，执行任务对象中的任务接口。

#ifndef __THREADPOOL_H_
#define __THREADPOOL_H_

#include <iostream>
#include <queue>
#include <pthread.h>
#include <unistd.h>
using namespace std;

typedef int (*hander) (int, int);

class Task
{
public:
    int _x;
    int _y;
    hander _func;
public:
    Task(const int& x, const int& y, hander func)
        :_x(x)
        ,_y(y)
        ,_func(func)
    {}
    void Run()
    {
        cout << pthread_self() << " result: " << _func(_x, _y) << endl;
    }
};

class ThreadPool
{
private:
    queue<Task> task_queue; //任务队列
    size_t thread_count;
    pthread_mutex_t mutex; //对任务队列的操作需保证线程安全
    pthread_cond_t cond; //任务队列为空时阻塞线程，加入新任务时唤醒线程。
private:
    void LockQueue()
    {
        pthread_mutex_lock(&mutex);
    }
    void UnLockQueue()
    {
        pthread_mutex_unlock(&mutex);
    }
    void BlockThread()
    {
        pthread_cond_wait(&cond, &mutex);
    }
    void SignalThread()
    {
        pthread_cond_signal(&cond);
    }
    Task GetTask()
    {
        Task t = task_queue.front();
        task_queue.pop();
        return t;
    }

public:
    ThreadPool(size_t count = 3)
        :thread_count(count)
    {}
    static void *run_func(void *arg) //static函数没有参数this
    {
        ThreadPool *tp = (ThreadPool *)arg; //不能用this指针，使用参数传入一个对象指针，用来访问成员方法
        while(1) //每个线程往复的拿任务，执行任务
        {
            tp->LockQueue();
            while(tp->task_queue.empty())
            {
                tp->BlockThread(); //当前没有任务，线程被阻塞
            }
            //poptaskqueue
            Task t = tp->GetTask();
            //unlockmutex
            tp->UnLockQueue();
            //runtask
            t.Run(); //在锁外执行任务
        }
    }
    void InitThreadPool()
    {
        pthread_mutex_init(&mutex, NULL);
        pthread_cond_init(&cond, NULL);
        pthread_t tid;
        while(thread_count--)
        {
            pthread_create(&tid, NULL, run_func, (void *)this);
        }
    }
    void PutTask(const Task& t)
    {
        LockQueue();
        task_queue.push(t);
        UnLockQueue();
        SignalThread(); //当有新任务时，唤醒可能被阻塞的线程
    }
    ~ThreadPool()
    {
        pthread_mutex_destroy(&mutex);
        pthread_cond_destroy(&cond);
    }
};

class Singleton //单例
{
private:
    static ThreadPool *tp;
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
public:
    ThreadPool *GetInstance()
    {
        if(tp == NULL)
        {
            pthread_mutex_lock(&mutex); //为null时再加锁，避免当已经存在对象时仍需要等待获得锁
            if(tp == NULL) //再次判断可避免在第一次判断和获得锁之间，有其他线程先一步为单例获得对象，而导致非单例
            {
                tp = new ThreadPool(5);
                tp->InitThreadPool();
            }
            pthread_mutex_unlock(&mutex);
        }
        return tp;
    }
};

ThreadPool *Singleton::tp = NULL;

#endif

#include "threadpool.hpp"
#include <cstdlib>
#include <ctime>

int Add(int x, int y)
{
    return x + y;
}
int Sub(int x, int y)
{
    return x - y;
}
int Mul(int x, int y)
{
    return x * y;
}
int Div(int x, int y)
{
    return x / y;
}

int main()
{
    srand((unsigned int)time(NULL));
    hander func_arr[] = {Add, Sub, Mul, Div}; //模拟线程执行的任务
    ThreadPool *tp = Singleton().GetInstance();
    while(1)
    {
        int x = rand() % 20 + 1;
        int y = rand() % 5 + 1;
        int index = rand() % 4;
        Task t = Task(x, y, func_arr[index]);
        cout << "Put task: " << x << " "<< index << " " << y << endl;
        tp->PutTask(t);
        sleep(1);
    }
    return 0;
}