tars源码漫谈第45篇------tc_thread_pool.h/tc_thread_pool.cpp（利用线程池提高效率）
在client/server交互操作中， 如果频繁创建和销毁socket, 对系统的性能有影响。 此时， 可以考虑复用， 当资源使用完后， 不要立即释放， 而是放在一个池子中， 直接供下次使用， 我们可以称这个操作为连接池。 这跟缓存的逻辑， 有点类似。
线程也是一样， 如果频繁创建和销毁， 会影响性能， 何不创建线程池？ 之前介绍线程条件变量的时候， 我们在主线程中wait, 然后在子线程中signal来唤醒wait, 同理， 也可以在主线程中通过signal来唤醒子线程的wait, 线程池就可以借助此思路： 让干活的线程不要退出， 而处于循环等待唤醒的时刻， 唤醒后， 开始干活。
直接借鉴https://blog.csdn.net/loshen1/article/details/7498369中的例子， 来看看代码：
#include
#include
#include
#include
#include
#include
/*
*线程池里所有运行和等待的任务都是一个CThread_worker
*由于所有任务都在链表里，所以是一个链表结构
*/
typedef struct worker
{
/*回调函数，任务运行时会调用此函数，注意也可声明成其它形式*/
void *(*process) (void *arg);
void *arg;/*回调函数的参数*/
struct worker *next;
} CThread_worker;
/*线程池结构*/
typedef struct
{
pthread_mutex_t queue_lock;
pthread_cond_t queue_ready;
/*链表结构，线程池中所有等待任务*/
CThread_worker *queue_head;
/*是否销毁线程池*/
int shutdown;
pthread_t *threadid;
/*线程池中允许的活动线程数目*/
int max_thread_num;
/*当前等待队列的任务数目*/
int cur_queue_size;
} CThread_pool;
int pool_add_worker (void *(*process) (void *arg), void *arg);
void *thread_routine (void *arg);
static CThread_pool *pool = NULL;
void pool_init (int max_thread_num)
{
pool = (CThread_pool *) malloc (sizeof (CThread_pool));
pthread_mutex_init (&(pool->queue_lock), NULL);
pthread_cond_init (&(pool->queue_ready), NULL);
pool->queue_head = NULL;
pool->max_thread_num = max_thread_num;
pool->cur_queue_size = 0;
pool->shutdown = 0;
pool->threadid = (pthread_t *) malloc (max_thread_num * sizeof (pthread_t));
int i = 0;
for (i = 0; i < max_thread_num; i++)
{
pthread_create (&(pool->threadid[i]), NULL, thread_routine,NULL);
}
}
/*向线程池中加入任务*/
int pool_add_worker (void *(*process) (void *arg), void *arg)
{
/*构造一个新任务*/
CThread_worker *newworker = (CThread_worker *) malloc (sizeof (CThread_worker));
newworker->process = process;
newworker->arg = arg;
newworker->next = NULL;/*别忘置空*/
pthread_mutex_lock (&(pool->queue_lock));
/*将任务加入到等待队列中*/
CThread_worker *member = pool->queue_head;
if (member != NULL)
{
while (member->next != NULL)
member = member->next;
member->next = newworker;
}
else
{
pool->queue_head = newworker;
}
assert (pool->queue_head != NULL);
pool->cur_queue_size++;
pthread_mutex_unlock (&(pool->queue_lock));
/*好了，等待队列中有任务了，唤醒一个等待线程；
注意如果所有线程都在忙碌，这句没有任何作用*/
pthread_cond_signal (&(pool->queue_ready));
return 0;
}
/*销毁线程池，等待队列中的任务不会再被执行，但是正在运行的线程会一直
把任务运行完后再退出*/
int pool_destroy ()
{
if (pool->shutdown)
return -1;/*防止两次调用*/
pool->shutdown = 1;
/*唤醒所有等待线程，线程池要销毁了*/
pthread_cond_broadcast (&(pool->queue_ready));
/*阻塞等待线程退出，否则就成僵尸了*/
int i;
for (i = 0; i < pool->max_thread_num; i++)
pthread_join (pool->threadid[i], NULL);
free (pool->threadid);
/*销毁等待队列*/
CThread_worker *head = NULL;
while (pool->queue_head != NULL)
{
head = pool->queue_head;
pool->queue_head = pool->queue_head->next;
free (head);
}
/*条件变量和互斥量也别忘了销毁*/
pthread_mutex_destroy(&(pool->queue_lock));
pthread_cond_destroy(&(pool->queue_ready));
free (pool);
/*销毁后指针置空是个好习惯*/
pool=NULL;
return 0;
}
void *
thread_routine (void *arg)
{
printf ("starting thread 0x%x\n", pthread_self ());
while (1)
{
pthread_mutex_lock (&(pool->queue_lock));
/*如果等待队列为0并且不销毁线程池，则处于阻塞状态; 注意
pthread_cond_wait是一个原子操作，等待前会解锁，唤醒后会加锁*/
while (pool->cur_queue_size == 0 && !pool->shutdown)
{
printf ("thread 0x%x is waiting\n", pthread_self ());
pthread_cond_wait (&(pool->queue_ready), &(pool->queue_lock));
}
/*线程池要销毁了*/
if (pool->shutdown)
{
/*遇到break,continue,return等跳转语句，千万不要忘记先解锁*/
pthread_mutex_unlock (&(pool->queue_lock));
printf ("thread 0x%x will exit\n", pthread_self ());
pthread_exit (NULL);
}
printf ("thread 0x%x is starting to work\n", pthread_self ());
/*assert是调试的好帮手*/
assert (pool->cur_queue_size != 0);
assert (pool->queue_head != NULL);
/*等待队列长度减去1，并取出链表中的头元素*/
pool->cur_queue_size--;
CThread_worker *worker = pool->queue_head;
pool->queue_head = worker->next;
pthread_mutex_unlock (&(pool->queue_lock));
/*调用回调函数，执行任务*/
(*(worker->process)) (worker->arg);
free(worker);
worker = NULL;
}
/*这一句应该是不可达的*/
pthread_exit (NULL);
}
void *
myprocess (void *arg)
{
printf ("threadid is 0x%x, working on task %d\n", pthread_self (),*(int *) arg);
sleep (1);/*休息一秒，延长任务的执行时间*/
return NULL;
}
int
main (int argc, char **argv)
{
pool_init (3);/*线程池中最多三个活动线程*/
/*连续向池中投入10个任务*/
int *workingnum = (int *) malloc (sizeof (int) * 10);
int i;
for (i = 0; i < 10; i++)
{
workingnum[i] = i;
pool_add_worker (myprocess, &workingnum[i]);
}
/*等待所有任务完成*/
sleep (5);
/*销毁线程池*/
pool_destroy ();
free (workingnum);
return 0;
}
运行一下：
ubuntu@VM-0-15-ubuntu:~/taoge/cpp$ ./a.out
starting thread 0x276f700
thread 0x276f700 is starting to work
threadid is 0x276f700, working on task 0
starting thread 0x2f70700
thread 0x2f70700 is starting to work
threadid is 0x2f70700, working on task 1
starting thread 0x3771700
thread 0x3771700 is starting to work
threadid is 0x3771700, working on task 2
thread 0x276f700 is starting to work
threadid is 0x276f700, working on task 3
thread 0x2f70700 is starting to work
threadid is 0x2f70700, working on task 4
thread 0x3771700 is starting to work
threadid is 0x3771700, working on task 5
thread 0x276f700 is starting to work
threadid is 0x276f700, working on task 6
thread 0x2f70700 is starting to work
threadid is 0x2f70700, working on task 7
thread 0x3771700 is starting to work
threadid is 0x3771700, working on task 8
thread 0x276f700 is starting to work
threadid is 0x276f700, working on task 9
thread 0x2f70700 is waiting
thread 0x3771700 is waiting
thread 0x276f700 is waiting
thread 0x2f70700 will exit
thread 0x3771700 will exit
thread 0x276f700 will exit
ubuntu@VM-0-15-ubuntu:~/taoge/cpp$ 可见， 总共创建了三个线程， 干活的子线程调用pthread_cond_wait来等待主线程用pthread_cond_signal来唤醒， 很好懂。apue中有一个很好的例子， 执行任务的线程在循环wait, 添加任务的线程会signal, 一个发号施令， 一个干活。 你情我愿， 一个愿打，一个愿挨！
tc_thread_pool中也是实现类似的功能， TC_ThreadPool是一个线程池管理类， 操控全局。 而如下的定义和上述代码的意思几乎一致：
protected:
/**
* 任务队列
*/
TC_ThreadQueue _jobqueue;
/**
* 启动任务
*/
TC_ThreadQueue _startqueue;
/**
* 工作线程
*/
std::vector _jobthread;
/**
* 繁忙线程
*/
std::set _busthread;
/**
* 任务队列的锁
*/
TC_ThreadLock _tmutex;
/**
* 是否所有任务都执行完毕
*/
bool _bAllDone; 再看看cpp源码：
/**
* Tencent is pleased to support the open source community by making Tars available.
*
* Copyright (C) 2016THL A29 Limited, a Tencent company. All rights reserved.
*
* Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* https://opensource.org/licenses/BSD-3-Clause
*
* Unless required by applicable law or agreed to in writing, software distributed
* under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the
* specific language governing permissions and limitations under the License.
*/
#include "util/tc_thread_pool.h"
#include "util/tc_common.h"
#include
namespace tars
{
TC_ThreadPool::ThreadWorker::ThreadWorker(TC_ThreadPool *tpool)
: _tpool(tpool)
, _bTerminate(false)
{
}
void TC_ThreadPool::ThreadWorker::terminate()
{
_bTerminate = true;
_tpool->notifyT();
}
void TC_ThreadPool::ThreadWorker::run()
{
//调用初始化部分
TC_FunctorWrapperInterface *pst = _tpool->get();
if(pst)
{
try
{
(*pst)();
}
catch ( ... )
{
}
delete pst;
pst = NULL;
}
//调用处理部分
while (!_bTerminate)
{
TC_FunctorWrapperInterface *pfw = _tpool->get(this);
if(pfw != NULL)
{
auto_ptr apfw(pfw);
try
{
(*pfw)();
}
catch ( ... )
{
}
_tpool->idle(this);
}
}
//结束
_tpool->exit();
}
//////////////////////////////////////////////////////////////
//
//
TC_ThreadPool::KeyInitialize TC_ThreadPool::g_key_initialize;
pthread_key_t TC_ThreadPool::g_key;
void TC_ThreadPool::destructor(void *p)
{
ThreadData *ttd = (ThreadData*)p;
if(ttd)
{
delete ttd;
}
}
void TC_ThreadPool::exit()
{
TC_ThreadPool::ThreadData *p = getThreadData();
if(p)
{
delete p;
int ret = pthread_setspecific(g_key, NULL);
if(ret != 0)
{
throw TC_ThreadPool_Exception("[TC_ThreadPool::setThreadData] pthread_setspecific error", ret);
}
}
_jobqueue.clear();
}
void TC_ThreadPool::setThreadData(TC_ThreadPool::ThreadData *p)
{
TC_ThreadPool::ThreadData *pOld = getThreadData();
if(pOld != NULL && pOld != p)
{
delete pOld;
}
int ret = pthread_setspecific(g_key, (void *)p);
if(ret != 0)
{
throw TC_ThreadPool_Exception("[TC_ThreadPool::setThreadData] pthread_setspecific error", ret);
}
}
TC_ThreadPool::ThreadData* TC_ThreadPool::getThreadData()
{
return (ThreadData *)pthread_getspecific(g_key);
}
void TC_ThreadPool::setThreadData(pthread_key_t pkey, ThreadData *p)
{
TC_ThreadPool::ThreadData *pOld = getThreadData(pkey);
if(pOld != NULL && pOld != p)
{
delete pOld;
}
int ret = pthread_setspecific(pkey, (void *)p);
if(ret != 0)
{
throw TC_ThreadPool_Exception("[TC_ThreadPool::setThreadData] pthread_setspecific error", ret);
}
}
TC_ThreadPool::ThreadData* TC_ThreadPool::getThreadData(pthread_key_t pkey)
{
return (ThreadData *)pthread_getspecific(pkey);
}
TC_ThreadPool::TC_ThreadPool()
: _bAllDone(true)
{
}
TC_ThreadPool::~TC_ThreadPool()
{
stop();
clear();
}
void TC_ThreadPool::clear()
{
std::vector::iterator it = _jobthread.begin();
while(it != _jobthread.end())
{
delete (*it);
++it;
}
_jobthread.clear();
_busthread.clear();
}
void TC_ThreadPool::init(size_t num)
{
stop();
Lock sync(*this);
clear();
for(size_t i = 0; i < num; i++)
{
_jobthread.push_back(new ThreadWorker(this));
}
}
void TC_ThreadPool::stop()
{
Lock sync(*this);
std::vector::iterator it = _jobthread.begin();
while(it != _jobthread.end())
{
if ((*it)->isAlive())
{
(*it)->terminate();
(*it)->getThreadControl().join();
}
++it;
}
_bAllDone = true;
}
void TC_ThreadPool::start()
{
Lock sync(*this);
std::vector::iterator it = _jobthread.begin();
while(it != _jobthread.end())
{
(*it)->start();
++it;
}
_bAllDone = false;
}
bool TC_ThreadPool::finish()
{
return _startqueue.empty() && _jobqueue.empty() && _busthread.empty() && _bAllDone;
}
bool TC_ThreadPool::waitForAllDone(int millsecond)
{
Lock sync(_tmutex);
start1:
//任务队列和繁忙线程都是空的
if (finish())
{
return true;
}
//永远等待
if(millsecond < 0)
{
_tmutex.timedWait(1000);
goto start1;
}
int64_t iNow= TC_Common::now2ms();
int m = millsecond;
start2:
bool b = _tmutex.timedWait(millsecond);
//完成处理了
if(finish())
{
return true;
}
if(!b)
{
return false;
}
millsecond = max((int64_t)0, m - (TC_Common::now2ms() - iNow));
goto start2;
return false;
}
TC_FunctorWrapperInterface *TC_ThreadPool::get(ThreadWorker *ptw)
{
TC_FunctorWrapperInterface *pFunctorWrapper = NULL;
if(!_jobqueue.pop_front(pFunctorWrapper, 1000))
{
return NULL;
}
{
Lock sync(_tmutex);
_busthread.insert(ptw);
}
return pFunctorWrapper;
}
TC_FunctorWrapperInterface *TC_ThreadPool::get()
{
TC_FunctorWrapperInterface *pFunctorWrapper = NULL;
if(!_startqueue.pop_front(pFunctorWrapper))
{
return NULL;
}
return pFunctorWrapper;
}
void TC_ThreadPool::idle(ThreadWorker *ptw)
{
Lock sync(_tmutex);
_busthread.erase(ptw);
//无繁忙线程, 通知等待在线程池结束的线程醒过来
if(_busthread.empty())
{
_bAllDone = true;
_tmutex.notifyAll();
}
}
void TC_ThreadPool::notifyT()
{
_jobqueue.notifyT();
}
}
仔细分析一下， 也是很好懂的（尽管有仿函数）。 类中类的定义， 也很妙。