线程池

在面向对象程序编程中,对象的创建与析构都是一个较为复杂的过程,较费时间,所以为了提高程序的运行效率尽可能减少创建和销毁对象的次数,特别是一些很耗资源的对象创建和销毁。
所以我们可以创建一个进程池(线程池),预先放一些进程(线程)进去,要用的时候就直接调用,用完之后再把进程归还给进程池,省下创建删除进程的时间,不过当然就需要额外的开销了。
利用线程池与进程池可以使管理进程与线程的工作交给系统管理,不需要程序员对里面的线程、进程进行管理。

以进程池为例

进程池是由服务器预先创建的一组子进程,这些子进程的数目在 3~10 个之间(当然这只是典型情况)。线程池中的线程数量应该和CPU数量差不多。

进程池中的所有子进程都运行着相同的代码,并具有相同的属性,比如优先级、 PGID 等。
当有新的任务来到时,主进程将通过某种方式选择进程池中的某一个子进程来为之服务。相比于动态创建子进程,选择一个已经存在的子进程的代价显得小得多。至于主进程选择哪个子进程来为新任务服务,则有两种方法:

主进程使用某种算法来主动选择子进程。最简单、最常用的算法是随机算法和Round Robin(轮流算法)。

主进程和所有子进程通过一个共享的工作队列来同步,子进程都睡眠在该工作队列上。当有新的任务到来时,主进程将任务添加到工作队列中。这将唤醒正在等待任务的子进程,不过只有一个子进程将获得新任务的“接管权”,它可以从工作队列中取出任务并执行之,而其他子进程将继续睡眠在工作队列上。

当选择好子进程后,主进程还需要使用某种通知机制来告诉目标子进程有新任务需要处理,并传递必要的数据。最简单的方式是,在父进程和子进程之间预先建立好一条管道,然后通过管道来实现所有的进程间通信。在父线程和子线程之间传递数据就要简单得多,因为我们可以把这些数据定义为全局,那么它们本身就是被所有线程共享的。

线程池的应用

线程池主要用于
1、需要大量的线程来完成任务,且完成任务的时间比较短。
WEB服务器完成网页请求这样的任务,使用线程池技术是非常合适的。
因为单个任务小,而任务数量巨大,一个热门网站的点击次数会很多。
但对于长时间的任务,比如一个Telnet连接请求,线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。

2、对性能要求苛刻的应用,比如要求服务器迅速响应客户请求。

3、接受突发性的大量请求,但不至于使服务器因此产生大量线程的应用。

线程池&&进程池的好处
进程池进程池减少了创建,归还的时间。提高了效率。

用C++模拟线程池
Linux系统下用C语言创建的一个线程池。线程池会维护一个任务链表(每个CThread_worker结构就是一个任务)。
pool_init()函数预先创建好max_thread_num个线程,每个线程执thread_routine ()函数。该函数中

while (pool->cur_queue_size == 0)
{
      pthread_cond_wait (&(pool->queue_ready),&(pool->queue_lock));
}

表示如果任务链表中没有任务,则该线程出于阻塞等待状态。否则从队列中取出任务并执行。
pool_add_worker()函数向线程池的任务链表中加入一个任务,加入后通过调用pthread_cond_signal (&(pool->queue_ready))唤醒一个出于阻塞状态的线程(如果有的话)。
pool_destroy ()函数用于销毁线程池,线程池任务链表中的任务不会再被执行,但是正在运行的线程会一直把任务运行完后再退出。

#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <sys/types.h>  
#include <pthread.h>  
#include <assert.h>  

/* 
*线程池里所有运行和等待的任务都是一个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;  
}  

这里写图片描述
这里写图片描述

理解
void pool_init (int max_thread_num) 初始化互斥锁和条件变量,创建一定数量的线程,每个线程都运行thread_routine 函数,该函数是检查任务队列是否为0,如果为0,则阻塞,直到有任务产生;否则,唤醒一个线程去执行任务队列中的队首任务,并将任务队列数减1。

int pool_add_worker (void *(*process) (void *arg), void *arg) 将任务加入任务队列,并唤醒线程

int pool_destroy () 销毁任务队列、互斥锁、条件变量,等待线程退出。

转自
https://blog.csdn.net/sayhello_world/article/details/72829329

设置正确的线程数量

《高性能服务器架构 》中提到了SEDA,我搜了一下,发现这篇文章《SEDA性能优化的分析和模拟 》,对于线程数量的建议。假如一个Web请求,代码执行的时间为ST(Service Time),读文件、网络调用之类IO等待时间为为WT(Wait Time),CPU的个数是N、核数是M则线程数量TC(Thread Count)为:

TC= N*M*(1+WT/ST)

假如只有1个单核的CPU,如果IO为40毫秒,程序执行要20毫秒,那么可以得出如下的执行序列。
Request1 执行20毫秒,等待40毫秒,此时CPU空闲。
Request2 接着执行20毫秒,等待40毫秒,此时Request1还需要等待20毫秒。
Request3 接着执行20毫秒,等待40毫秒,此时Request2还需要等待20毫秒,Request1执行完毕。
Request4 就可以重用Request1的线程了。

按照这个公式,假如1个单核的CPU,存在下面三种应用场景:
S1:ST=10 WT=0 TC=1
S2:ST=10 WT=50 TC=6
S3:ST=10 WT=100 TC=11
S1是纯粹的计算,没有IO,只消耗CPU;S2是本地文件的访问,有磁盘IO;S3是调用数据库,有网络IO。
假如S1占总请求数量的10%,S2占20%,S3占70%,此时的TC应该是多少?假如百分比为PER

TC = N*M*(1 + ( WT1*PER1 + WT2*PER2 ... WTn*PERn)/( ST1*PER1 + ST2*PER2 ... STn*PERn) )

也就是 说总的等待时间/总的执行时间
上面的场景,按照公式为
TC = 1 * 1 * ( 1 + 80/10 ) = 9
也就是说设置9个线程是合适的。正确的估计每种场景,获得每种场景的数据,对于每种场景的比例做出分析,就大概能计算出线程数量的理论值。当然,也需要根据《压力测试衡量CPU的三个指标:CPU Utilization、Load Average和Context Switch Rate 》的数据来验证和调整。

转自
https://blog.csdn.net/benpaobagzb/article/details/51701787

阅读更多

没有更多推荐了,返回首页