文章目录
- 5.5线程同步机制类封装及线程池实现
- 线程池
- 线程同步机制类封装
- 线程池实现
5.5线程同步机制类封装及线程池实现
线程池
线程池是由服务器预先创建的一组子线程，线程池中的线程数据应该与CPU数据差不多。线程池中的所有子线程都运行着相同的代码。当有新的任务到来时，主线程将通过某种方式选择线程池中的某一个子线程来为之服务。相比与动态的创建子线程，选择一个已经存在的子线程的代价显然要小得多。至于主线程选择哪个子线程来为新任务服务，则有多种方式：
- 主线程使用某种算法来主动选择子线程。最简单、最常用的算法是随机算法和Round Robin（轮流选取）算法，但更优秀、更智能的算法将使任务在各个工作线程中更均匀地分配，从而减轻服务器的整体压力。
- 主线程和所有子线程通过一个共享的工作队列来同步，子线程都睡眠在该工作队列上。当有新的任务到来时，主线程将任务添加到工作队列中。这将唤醒正在等待任务的子线程，不过只有一个子线程将获得新任务的接管权，它可以从工作队列中取出任务并执行之，而其他子线程将继续睡眠在工作队列上。
线程池的一般模型为：
线程池中的线程数量最直接的限制因素是中央处理器（CPU）的处理器(process/cores)的数量N；如果你的CPU是4-cores的，对于CPU密集型的任务（如视频剪辑等消耗CPU计算资源的任务）来说，那线程池中的线程数量最好也设置为4（或者+1防止其他因素造成的线程阻塞）；对于IO密集型的任务，一般要多于CPU的核数，因为线程间竞争的不是CPU的计算资源而是IO，IO的处理一般较慢，多于cores数的线程将为CPU争取更多的任务，不至在线程处理IO的过程造成CPU空闲导致资源浪费。
- 空间换时间，浪费服务器的硬件资源，换取运行效率
- 池是一组资源的集合，这组资源在服务器启动之初就完全创建好并初始化，这称为静态资源
- 当服务器进入正式运行阶段，开始处理客户请求的时候，如果它需要相关的资源，可以直接从池中获取，无需动态分配
- 当服务器处理完一个客户连接后，可以把相关的资源放回池中，无需执行系统调用释放资源
线程同步机制类封装
#ifndef LOCKER_H
#define LOCKER_H
#include <exception>
#include <pthread.h>
#include <semaphore.h>
//线程同步机制封装类
//互斥锁类
class locker{
public:
locker(){
if(pthread_mutex_init(&m_mutex,NULL)!=0){
throw std::exception();
}
}
~locker(){
pthread_mutex_destroy(&m_mutex);
}
bool lock(){
return pthread_mutex_lock(&m_mutex)==0;
}
bool unlock(){
return pthread_mutex_unlock(&m_mutex)==0;
}
pthread_mutex_t *get(){
return &m_mutex;
}
private:
pthread_mutex_t m_mutex;
};
//条件变量类
class cond{
public:
cond(){
if(pthread_cond_init(&m_cond,NULL)!=0){
throw std::exception();
}
}
~cond(){
pthread_cond_destroy(&m_cond);
}
bool wait(pthread_mutex_t *m_mutex){
int ret=0;
//pthread_cond_wait()线程同步函数，用于等待条件变量的信号
//当线程调用该函数时，它会释放锁并进入等待状态，直到另一个线程发出信号并通知该线程条件变量已经满足
//此时，该线程会重新获得锁并继续执行
ret=pthread_cond_wait(&m_cond,m_mutex);
return ret==0;
}
bool timewait(pthread_mutex_t *m_mutex,struct timespec t){
//struct timespec t提供秒和纳秒级的时间精度
int ret=0;
//指定时间内有信号传过来时，pthread_cond_timedwait()返回0，否则返回一个非0数
ret=pthread_cond_timedwait(&m_cond,m_mutex,&t);
return ret==0;
}
bool signal(){
//通知其他线程某个条件已经满足的函数
return pthread_cond_signal(&m_cond)==0;
}
bool broadcast(){
//唤醒所有在条件变量上等待的线程的函数
return pthread_cond_broadcast(&m_cond)==0;
}
private:
pthread_cond_t m_cond;
};
//信号量类
class sem{
public:
sem(){
//sem_init()：初始化一个信号量
//第二个参数0表示此信号量只能为当前进程的所有线程共享
//第三个参数0表示信号量的初始值为0
if(sem_init(&m_sem,0,0)!=0){
throw std::exception();
}
}
sem(int num){
if(sem_init(&m_sem,0,num)!=0){
throw std::exception();
}
}
~sem(){
sem_destroy(&m_sem);
}
//等待信号量
//从信号量的值减去一个1，但它永远会先等待该信号量为一个非零值才开始做减法
bool wait(){
return sem_wait(&m_sem)==0;
}
//增加信号量
//给信号量的值加上一个1，当有线程阻塞在这个信号量上时，调用这个函数会使其中一个线程不再阻塞
bool post(){
return sem_post(&m_sem)==0;
}
private:
sem_t m_sem;
};
#endif
线程池实现
#ifndef THREADPOOL_H
#define THREADPOOL_H
#include <list>
#include <cstdio>
#include <exception>
#include <pthread.h>
#include "locker.h"
// 线程池类，将它定义为模板类是为了代码复用，模板参数T是任务类
template<typename T>
class threadpool {
public:
/*thread_number是线程池中线程的数量，max_requests是请求队列中最多允许的、等待处理的请求的数量*/
threadpool(int thread_number = 8, int max_requests = 10000);
~threadpool();
bool append(T* request);
private:
/*工作线程运行的函数，它不断从工作队列中取出任务并执行之*/
static void* worker(void* arg);
void run();
private:
// 线程的数量
int m_thread_number;
// 描述线程池的数组，大小为m_thread_number
pthread_t * m_threads;
// 请求队列中最多允许的、等待处理的请求的数量
int m_max_requests;
// 请求队列
std::list< T* > m_workqueue;
// 保护请求队列的互斥锁
locker m_queuelocker;
// 是否有任务需要处理
sem m_queuestat;
// 是否结束线程
bool m_stop;
};
template< typename T >
threadpool< T >::threadpool(int thread_number, int max_requests) :
m_thread_number(thread_number), m_max_requests(max_requests),
m_stop(false), m_threads(NULL) {
if((thread_number <= 0) || (max_requests <= 0) ) {
throw std::exception();
}
m_threads = new pthread_t[m_thread_number];
if(!m_threads) {
throw std::exception();
}
// 创建thread_number 个线程，并将他们设置为脱离线程。
for ( int i = 0; i < thread_number; ++i ) {
printf( "create the %dth thread\n", i);
if(pthread_create(m_threads + i, NULL, worker, this ) != 0) {
delete [] m_threads;
throw std::exception();
}
if( pthread_detach( m_threads[i] ) ) {
delete [] m_threads;
throw std::exception();
}
}
}
template< typename T >
threadpool< T >::~threadpool() {
delete [] m_threads;
m_stop = true;
}
template< typename T >
bool threadpool< T >::append( T* request )
{
// 操作工作队列时一定要加锁，因为它被所有线程共享。
m_queuelocker.lock();
if ( m_workqueue.size() > m_max_requests ) {
m_queuelocker.unlock();
return false;
}
m_workqueue.push_back(request);
m_queuelocker.unlock();
m_queuestat.post();
return true;
}
template< typename T >
void* threadpool< T >::worker( void* arg )
{
threadpool* pool = ( threadpool* )arg;
pool->run();
return pool;
}
template< typename T >
void threadpool< T >::run() {
while (!m_stop) {
m_queuestat.wait();
m_queuelocker.lock();
if ( m_workqueue.empty() ) {
m_queuelocker.unlock();
continue;
}
T* request = m_workqueue.front();
m_workqueue.pop_front();
m_queuelocker.unlock();
if ( !request ) {
continue;
}
request->process();
}
}
#endif
