linux 网卡队列 线程,Linux网络编程：线程池的使用

一、什么是线程池

应用程序可以有多个线程，这些线程在休眠状态中需要耗费大量时间来等待事件发生。其他线程可能进入睡眠状态，并且仅定期被唤醒以轮循更改或更新状态信息，然后再次进入休眠状态。为了简化对这些线程的管理，.NET框架为每个进程提供了一个线程池，一个线程池有若干个等待操作状态，当一个等待操作完成时，线程池中的辅助线程会执行回调函数。线程池中的线程由系统管理，程序员不需要费力于线程管理，可以集中精力处理应用程序任务。

线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程.每个线程都使用默认的堆栈大小,以默认的优先级运行,并处于多线程单元中.如果某个线程在托管代码中空闲(如正在等待某个事件),则线程池将插入另一个辅助线程来使所有处理器保持繁忙.如果所有线程池线程都始终保持繁忙,但队列中包含挂起的工作,则线程池将在一段时间后创建另一个辅助线程但线程的数目永远不会超过最大值.超过最大值的线程可以排队,但他们要等到其他线程完成后才启动

二、什么情况下不要使用线程池

●如果需要使一个任务具有特定优先级

●如果具有可能会长时间运行(并因此阻塞其他任务)的任务

●如果需要将线程放置到单线程单元中(线程池中的线程均处于多线程单元中)

●如果需要永久标识来标识和控制线程，比如想使用专用线程来终止该线程，将其挂起或按名称发现它

下面给出一个线程池的例子，以供大家参考：

[cpp]

#include 

#include 

#include 

#include 

#include 

#include 

/*

*线程池里所有运行和等待的任务都是一个CThread_worker

*由于所有任务都在链表里，所以是一个链表结构

*/

typedefstructworker

{

/*回调函数，任务运行时会调用此函数，注意也可声明成其它形式*/

void*(*process) (void*arg);

void*arg;/*回调函数的参数*/

structworker *next;

} CThread_worker;

/*线程池结构*/

typedefstruct

{

pthread_mutex_t queue_lock;

pthread_cond_t queue_ready;

/*链表结构，线程池中所有等待任务*/

CThread_worker *queue_head;

/*是否销毁线程池*/

intshutdown;

pthread_t *threadid;

/*线程池中允许的活动线程数目*/

intmax_thread_num;

/*当前等待队列的任务数目*/

intcur_queue_size;

} CThread_pool;

intpool_add_worker (void*(*process) (void*arg),void*arg);

void*thread_routine (void*arg);

staticCThread_pool *pool = NULL;

voidpool_init (intmax_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));

inti = 0;

for(i = 0; 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));

return0;

}

/*销毁线程池，等待队列中的任务不会再被执行，但是正在运行的线程会一直

把任务运行完后再退出*/

intpool_destroy ()

{

if(pool->shutdown)

return-1;/*防止两次调用*/

pool->shutdown = 1;

/*唤醒所有等待线程，线程池要销毁了*/

pthread_cond_broadcast (&(pool->queue_ready));

/*阻塞等待线程退出，否则就成僵尸了*/

inti;

for(i = 0; i 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;

return0;

}

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);/*休息一秒，延长任务的执行时间*/

returnNULL;

}

intmain (intargc,char**argv)

{

pool_init (3);/*线程池中最多三个活动线程*/

/*连续向池中投入10个任务*/

int*workingnum = (int*) malloc (sizeof(int) * 10);

inti;

for(i = 0; i 

{

workingnum[i] = i;

pool_add_worker (myprocess, &workingnum[i]);

}

/*等待所有任务完成*/

sleep (5);

/*销毁线程池*/

pool_destroy ();

free (workingnum);

return0;

}