zoukankan      html  css  js  c++  java

  • linux中线程池【转】

    本文转载自:http://blog.csdn.net/yusiguyuan/article/details/18401277

    一、线程池

    大多数的网络服务器，包括Web服务器都具有一个特点，就是单位时间内必须处理数目巨大的连接请求，但是处理时间却是比较短的。在传统的多线程服务器模型中是这样实现的：一旦有个请求到达，就创建一个新的线程，由该线程执行任务，任务执行完毕之后，线程就退出。这就是"即时创建，即时销毁"的策略。尽管与创建进程相比，创建线程的时间已经大大的缩短，但是如果提交给线程的任务是执行时间较短，而且执行次数非常频繁，那么服务器就将处于一个不停的创建线程和销毁线程的状态。这笔开销是不可忽略的，尤其是线程执行的时间非常非常短的情况。

    　　线程池就是为了解决上述问题的，它的实现原理是这样的：在应用程序启动之后，就马上创建一定数量的线程，放入空闲的队列中。这些线程都是处于阻塞状态，这些线程只占一点内存，不占用CPU。当任务到来后，线程池将选择一个空闲的线程，将任务传入此线程中运行。当所有的线程都处在处理任务的时候，线程池将自动创建一定的数量的新线程，用于处理更多的任务。执行任务完成之后线程并不退出，而是继续在线程池中等待下一次任务。当大部分线程处于阻塞状态时，线程池将自动销毁一部分的线程，回收系统资源。

    　　下面是一个简单线程池的实现，这个线程池的代码是我参考网上的一个例子实现的，由于找不到出处了，就没办法注明参考自哪里了。它的方案是这样的：程序启动之前，初始化线程池，启动线程池中的线程，由于还没有任务到来，线程池中的所有线程都处在阻塞状态，当一有任务到达就从线程池中取出一个空闲线程处理，如果所有的线程都处于工作状态，就添加到队列，进行排队。如果队列中的任务个数大于队列的所能容纳的最大数量，那就不能添加任务到队列中，只能等待队列不满才能添加任务到队列中。

    　　主要由两个文件组成一个threadpool.h头文件和一个threadpool.c源文件组成。源码中已有重要的注释，就不加以分析了。

    　　threadpool.h文件：

    [cpp] view plaincopy
     
    1. struct job  
    2. {  
    3.     void* (*callback_function)(void *arg);    //线程回调函数  
    4.     void *arg;                                //回调函数参数  
    5.     struct job *next;  
    6. };  
    7.   
    8. struct threadpool  
    9. {  
    10.     int thread_num;                   //线程池中开启线程的个数  
    11.     int queue_max_num;                //队列中最大job的个数  
    12.     struct job *head;                 //指向job的头指针  
    13.     struct job *tail;                 //指向job的尾指针  
    14.     pthread_t *pthreads;              //线程池中所有线程的pthread_t  
    15.     pthread_mutex_t mutex;            //互斥信号量  
    16.     pthread_cond_t queue_empty;       //队列为空的条件变量  
    17.     pthread_cond_t queue_not_empty;   //队列不为空的条件变量  
    18.     pthread_cond_t queue_not_full;    //队列不为满的条件变量  
    19.     int queue_cur_num;                //队列当前的job个数  
    20.     int queue_close;                  //队列是否已经关闭  
    21.     int pool_close;                   //线程池是否已经关闭  
    22. };  
    23.   
    24. //================================================================================================  
    25. //函数名：                   threadpool_init  
    26. //函数描述：                 初始化线程池  
    27. //输入：                    [in] thread_num     线程池开启的线程个数  
    28. //                         [in] queue_max_num  队列的最大job个数   
    29. //输出：                    无  
    30. //返回：                    成功：线程池地址 失败：NULL  
    31. //================================================================================================  
    32. struct threadpool* threadpool_init(int thread_num, int queue_max_num);  
    33.   
    34. //================================================================================================  
    35. //函数名：                    threadpool_add_job  
    36. //函数描述：                  向线程池中添加任务  
    37. //输入：                     [in] pool                  线程池地址  
    38. //                          [in] callback_function     回调函数  
    39. //                          [in] arg                     回调函数参数  
    40. //输出：                     无  
    41. //返回：                     成功：0 失败：-1  
    42. //================================================================================================  
    43. int threadpool_add_job(struct threadpool *pool, void* (*callback_function)(void *arg), void *arg);  
    44.   
    45. //================================================================================================  
    46. //函数名：                    threadpool_destroy  
    47. //函数描述：                   销毁线程池  
    48. //输入：                      [in] pool                  线程池地址  
    49. //输出：                      无  
    50. //返回：                      成功：0 失败：-1  
    51. //================================================================================================  
    52. int threadpool_destroy(struct threadpool *pool);  
    53.   
    54. //================================================================================================  
    55. //函数名：                    threadpool_function  
    56. //函数描述：                  线程池中线程函数  
    57. //输入：                     [in] arg                  线程池地址  
    58. //输出：                     无    
    59. //返回：                     无  
    60. //================================================================================================  
    61. void* threadpool_function(void* arg);  

    　threadpool.c文件：

    [cpp] view plaincopy
     
    1. #include "threadpool.h"  
    2.   
    3. struct threadpool* threadpool_init(int thread_num, int queue_max_num)  
    4. {  
    5.     struct threadpool *pool = NULL;  
    6.     do   
    7.     {  
    8.         pool = malloc(sizeof(struct threadpool));  
    9.         if (NULL == pool)  
    10.         {  
    11.             printf("failed to malloc threadpool! ");  
    12.             break;  
    13.         }  
    14.         pool->thread_num = thread_num;  
    15.         pool->queue_max_num = queue_max_num;  
    16.         pool->queue_cur_num = 0;  
    17.         pool->head = NULL;  
    18.         pool->tail = NULL;  
    19.         if (pthread_mutex_init(&(pool->mutex), NULL))  
    20.         {  
    21.             printf("failed to init mutex! ");  
    22.             break;  
    23.         }  
    24.         if (pthread_cond_init(&(pool->queue_empty), NULL))  
    25.         {  
    26.             printf("failed to init queue_empty! ");  
    27.             break;  
    28.         }  
    29.         if (pthread_cond_init(&(pool->queue_not_empty), NULL))  
    30.         {  
    31.             printf("failed to init queue_not_empty! ");  
    32.             break;  
    33.         }  
    34.         if (pthread_cond_init(&(pool->queue_not_full), NULL))  
    35.         {  
    36.             printf("failed to init queue_not_full! ");  
    37.             break;  
    38.         }  
    39.         pool->pthreads = malloc(sizeof(pthread_t) * thread_num);  
    40.         if (NULL == pool->pthreads)  
    41.         {  
    42.             printf("failed to malloc pthreads! ");  
    43.             break;  
    44.         }  
    45.         pool->queue_close = 0;  
    46.         pool->pool_close = 0;  
    47.         int i;  
    48.         for (i = 0; i < pool->thread_num; ++i)  
    49.         {  
    50.             pthread_create(&(pool->pthreads[i]), NULL, threadpool_function, (void *)pool);  
    51.         }  
    52.           
    53.         return pool;      
    54.     } while (0);  
    55.       
    56.     return NULL;  
    57. }  
    58.   
    59. int threadpool_add_job(struct threadpool* pool, void* (*callback_function)(void *arg), void *arg)  
    60. {  
    61.     assert(pool != NULL);  
    62.     assert(callback_function != NULL);  
    63.     assert(arg != NULL);  
    64.   
    65.     pthread_mutex_lock(&(pool->mutex));  
    66.     while ((pool->queue_cur_num == pool->queue_max_num) && !(pool->queue_close || pool->pool_close))  
    67.     {  
    68.         pthread_cond_wait(&(pool->queue_not_full), &(pool->mutex));   //队列满的时候就等待  
    69.     }  
    70.     if (pool->queue_close || pool->pool_close)    //队列关闭或者线程池关闭就退出  
    71.     {  
    72.         pthread_mutex_unlock(&(pool->mutex));  
    73.         return -1;  
    74.     }  
    75.     struct job *pjob =(struct job*) malloc(sizeof(struct job));  
    76.     if (NULL == pjob)  
    77.     {  
    78.         pthread_mutex_unlock(&(pool->mutex));  
    79.         return -1;  
    80.     }   
    81.     pjob->callback_function = callback_function;      
    82.     pjob->arg = arg;  
    83.     pjob->next = NULL;  
    84.     if (pool->head == NULL)     
    85.     {  
    86.         pool->head = pool->tail = pjob;  
    87.         pthread_cond_broadcast(&(pool->queue_not_empty));  //队列空的时候，有任务来时就通知线程池中的线程：队列非空  
    88.     }  
    89.     else  
    90.     {  
    91.         pool->tail->next = pjob;  
    92.         pool->tail = pjob;      
    93.     }  
    94.     pool->queue_cur_num++;  
    95.     pthread_mutex_unlock(&(pool->mutex));  
    96.     return 0;  
    97. }  
    98.   
    99. void* threadpool_function(void* arg)  
    100. {  
    101.     struct threadpool *pool = (struct threadpool*)arg;  
    102.     struct job *pjob = NULL;  
    103.     while (1)  //死循环  
    104.     {  
    105.         pthread_mutex_lock(&(pool->mutex));  
    106.         while ((pool->queue_cur_num == 0) && !pool->pool_close)   //队列为空时，就等待队列非空  
    107.         {  
    108.             pthread_cond_wait(&(pool->queue_not_empty), &(pool->mutex));  
    109.         }  
    110.         if (pool->pool_close)   //线程池关闭，线程就退出  
    111.         {  
    112.             pthread_mutex_unlock(&(pool->mutex));  
    113.             pthread_exit(NULL);  
    114.         }  
    115.         pool->queue_cur_num--;  
    116.         pjob = pool->head;  
    117.         if (pool->queue_cur_num == 0)  
    118.         {  
    119.             pool->head = pool->tail = NULL;  
    120.         }  
    121.         else   
    122.         {  
    123.             pool->head = pjob->next;  
    124.         }  
    125.         if (pool->queue_cur_num == 0)  
    126.         {  
    127.             pthread_cond_signal(&(pool->queue_empty));        //队列为空，就可以通知threadpool_destroy函数，销毁线程函数  
    128.         }  
    129.         if (pool->queue_cur_num == pool->queue_max_num - 1)  
    130.         {  
    131.             pthread_cond_broadcast(&(pool->queue_not_full));  //队列非满，就可以通知threadpool_add_job函数，添加新任务  
    132.         }  
    133.         pthread_mutex_unlock(&(pool->mutex));  
    134.           
    135.         (*(pjob->callback_function))(pjob->arg);   //线程真正要做的工作，回调函数的调用  
    136.         free(pjob);  
    137.         pjob = NULL;      
    138.     }  
    139. }  
    140. int threadpool_destroy(struct threadpool *pool)  
    141. {  
    142.     assert(pool != NULL);  
    143.     pthread_mutex_lock(&(pool->mutex));  
    144.     if (pool->queue_close || pool->pool_close)   //线程池已经退出了，就直接返回  
    145.     {  
    146.         pthread_mutex_unlock(&(pool->mutex));  
    147.         return -1;  
    148.     }  
    149.       
    150.     pool->queue_close = 1;        //置队列关闭标志  
    151.     while (pool->queue_cur_num != 0)  
    152.     {  
    153.         pthread_cond_wait(&(pool->queue_empty), &(pool->mutex));  //等待队列为空  
    154.     }      
    155.       
    156.     pool->pool_close = 1;      //置线程池关闭标志  
    157.     pthread_mutex_unlock(&(pool->mutex));  
    158.     pthread_cond_broadcast(&(pool->queue_not_empty));  //唤醒线程池中正在阻塞的线程  
    159.     pthread_cond_broadcast(&(pool->queue_not_full));   //唤醒添加任务的threadpool_add_job函数  
    160.     int i;  
    161.     for (i = 0; i < pool->thread_num; ++i)  
    162.     {  
    163.         pthread_join(pool->pthreads[i], NULL);    //等待线程池的所有线程执行完毕  
    164.     }  
    165.       
    166.     pthread_mutex_destroy(&(pool->mutex));          //清理资源  
    167.     pthread_cond_destroy(&(pool->queue_empty));  
    168.     pthread_cond_destroy(&(pool->queue_not_empty));     
    169.     pthread_cond_destroy(&(pool->queue_not_full));      
    170.     free(pool->pthreads);  
    171.     struct job *p;  
    172.     while (pool->head != NULL)  
    173.     {  
    174.         p = pool->head;  
    175.         pool->head = p->next;  
    176.         free(p);  
    177.     }  
    178.     free(pool);  
    179.     return 0;  
    180. }  

    测试文件main.c文件：

    [cpp] view plaincopy
     
    1. #include "threadpool.h"  
    2.   
    3. void* work(void* arg)  
    4. {  
    5.     char *p = (char*) arg;  
    6.     printf("threadpool callback fuction : %s. ", p);  
    7.     sleep(1);  
    8. }  
    9.   
    10. int main(void)  
    11. {  
    12.     struct threadpool *pool = threadpool_init(10, 20);  
    13.     threadpool_add_job(pool, work, "1");  
    14.     threadpool_add_job(pool, work, "2");  
    15.     threadpool_add_job(pool, work, "3");  
    16.     threadpool_add_job(pool, work, "4");  
    17.     threadpool_add_job(pool, work, "5");  
    18.     threadpool_add_job(pool, work, "6");  
    19.     threadpool_add_job(pool, work, "7");  
    20.     threadpool_add_job(pool, work, "8");  
    21.     threadpool_add_job(pool, work, "9");  
    22.     threadpool_add_job(pool, work, "10");  
    23.     threadpool_add_job(pool, work, "11");  
    24.     threadpool_add_job(pool, work, "12");  
    25.     threadpool_add_job(pool, work, "13");  
    26.     threadpool_add_job(pool, work, "14");  
    27.     threadpool_add_job(pool, work, "15");  
    28.     threadpool_add_job(pool, work, "16");  
    29.     threadpool_add_job(pool, work, "17");  
    30.     threadpool_add_job(pool, work, "18");  
    31.     threadpool_add_job(pool, work, "19");  
    32.     threadpool_add_job(pool, work, "20");  
    33.     threadpool_add_job(pool, work, "21");  
    34.     threadpool_add_job(pool, work, "22");  
    35.     threadpool_add_job(pool, work, "23");  
    36.     threadpool_add_job(pool, work, "24");  
    37.     threadpool_add_job(pool, work, "25");  
    38.     threadpool_add_job(pool, work, "26");  
    39.     threadpool_add_job(pool, work, "27");  
    40.     threadpool_add_job(pool, work, "28");  
    41.     threadpool_add_job(pool, work, "29");  
    42.     threadpool_add_job(pool, work, "30");  
    43.     threadpool_add_job(pool, work, "31");  
    44.     threadpool_add_job(pool, work, "32");  
    45.     threadpool_add_job(pool, work, "33");  
    46.     threadpool_add_job(pool, work, "34");  
    47.     threadpool_add_job(pool, work, "35");  
    48.     threadpool_add_job(pool, work, "36");  
    49.     threadpool_add_job(pool, work, "37");  
    50.     threadpool_add_job(pool, work, "38");  
    51.     threadpool_add_job(pool, work, "39");  
    52.     threadpool_add_job(pool, work, "40");  
    53.   
    54.     sleep(5);  
    55.     threadpool_destroy(pool);  
    56.     return 0;  
    57. }  

    二、线程池补充

    上面的文章介绍了线程池的原理及意义。

    下面，介绍的这个线程池与上面提到的那个线程池有一部分相似的地方。

    　　主要区别为：

    　　　　1、线程池中的每个线程都有自己的互斥量和条件变量，而不是线程池共享一个。

    　　　　2、线程池中的线程在程序结束时，等待线程池中线程停止的机制不同。

    　　该程序主要由两个文件构成，分别为ThreadPool.h和ThreadPool.cpp文件。

    　　ThreadPool.h文件：

    [cpp] view plaincopy
     
    1. #define MAXT_IN_POOL 200  
    2. #define BUSY_THRESHOlD 0.5  
    3. #define MANAGE_INTREVAL 2  
    4.   
    5. class ThreadPool;  
    6.   
    7. typedef void (*dispatch_fn)(void*);      
    8.   
    9. //线程函数参数  
    10. typedef struct tagThread             
    11. {  
    12.     pthread_t thread_id;           //线程ID  
    13.     pthread_mutex_t thread_mutex;  //信号量  
    14.     pthread_cond_t thread_cond;    //条件变量  
    15.     dispatch_fn do_job;            //调用的函数，任务  
    16.     void* args;                    //函数参数  
    17.     ThreadPool *parent;            //线程池指针  
    18. }_thread;  
    19.   
    20. //线程池  
    21. class ThreadPool  
    22. {      
    23. public:  
    24.     //================================================================================================  
    25.     //函数名：                  ThreadPool  
    26.     //函数描述：                构造函数  
    27.     //输入：                    [in] max_threads_in_pool 线程池最大线程数  
    28.     //输入：                    [in] min_threads_in_pool 线程池最小问题数  
    29.     //输出：                    无  
    30.     //返回：                    无  
    31.     //================================================================================================  
    32.     ThreadPool(unsigned int max_threads_in_pool, unsigned int min_threads_in_pool = 2);  
    33.     ~ThreadPool();  
    34.       
    35.     //================================================================================================  
    36.     //函数名：                  dispatch_threadpool  
    37.     //函数描述：                将任务加入线程池，由线程池进行分发  
    38.     //输入：                    [in] dispatch_me 调用的函数地址  
    39.     //输入：                    [in] dispatch_me 函数参数  
    40.     //输出：                    无  
    41.     //返回：                    无  
    42.     //================================================================================================  
    43.     void dispatch_threadpool(dispatch_fn dispatch_me, void* dispatch_me);  
    44. private:  
    45.     pthread_mutex_t tp_mutex;  //信号量  
    46.     pthread_cond_t tp_idle;    //线程池中线程有空闲线程的条件变量  
    47.     pthread_cond_t tp_full;    //线程池中线程为满的条件变量   
    48.     pthread_cond_t tp_empty;   //线程池中线程为空的条件变量  
    49.     int tp_min;                //线程池的最小线程数  
    50.     int tp_max;                //线程池的最大线程数  
    51.     int tp_avail;              //线程池中空闲的线程数  
    52.     int tp_total;              //线程池中已创建的线程数  
    53.     _thread** tp_list;         //指向线程池中所有空闲线程的参数的指针  
    54.     bool tp_stop;              //线程池是否已停止  
    55.       
    56.     //================================================================================================  
    57.     //函数名：                  add_avail  
    58.     //函数描述：                加入空闲线程  
    59.     //输入：                    [in] avail 线程的参数  
    60.     //输出：                    无  
    61.     //返回：                    成功：true，失败：false  
    62.     //================================================================================================  
    63.     bool add_avail(_thread* avail);  
    64.       
    65.     //================================================================================================  
    66.     //函数名：                  work_thread  
    67.     //函数描述：                线程函数  
    68.     //输入：                    [in] args 参数  
    69.     //输出：                    无  
    70.     //返回：                    无  
    71.     //================================================================================================  
    72.     static void* work_thread(void* args);  
    73.       
    74.     //================================================================================================  
    75.     //函数名：                  add_thread  
    76.     //函数描述：                添加一个线程  
    77.     //输入：                    [in] dispatch_me 函数指针  
    78.     //输入：                    [in] args        函数参数  
    79.     //输出：                    无  
    80.     //返回：                    无  
    81.     //================================================================================================  
    82.     bool add_thread(dispatch_fn dispatch_me, void* args);  
    83.       
    84.     //================================================================================================  
    85.     //函数名：                  syn_all  
    86.     //函数描述：                等待线程池中所有线程空闲  
    87.     //输入：                    无  
    88.     //输出：                    无  
    89.     //返回：                    无  
    90.     //================================================================================================  
    91.     void syn_all();      
    92. };  

    ThreadPool.cpp文件：

    [cpp] view plaincopy
     
      1. ThreadPool::ThreadPool(unsigned int max_threads_in_pool, unsigned int min_threads_in_pool)  
      2. {  
      3.     pthread_t manage_id;  
      4.   
      5.     if (min_threads_in_pool <= 0 || max_threads_in_pool < 0 || min_threads_in_pool > max_threads_in_pool || max_threads_in_pool > MAXT_IN_POOL)  
      6.     {  
      7.         return ;  
      8.     }  
      9.   
      10.     tp_avail = 0;      //初始化线程池  
      11.     tp_total = 0;  
      12.     tp_min = min_threads_in_pool;  
      13.     tp_max = max_threads_in_pool;  
      14.     tp_stop = false;  
      15.     tp_list = (_thread * *)    malloc(sizeof(void *) * max_threads_in_pool);      
      16.     if (NULL == tp_list)  
      17.     {  
      18.         return;  
      19.     }  
      20.     memset(tp_list, 0, sizeof(void *) * max_threads_in_pool);  
      21.       
      22.     pthread_mutex_init(&tp_mutex, NULL);  
      23.     pthread_cond_init(&tp_idle, NULL);  
      24.     pthread_cond_init(&tp_full, NULL);  
      25.     pthread_cond_init(&tp_empty, NULL);  
      26. }  
      27.   
      28. bool ThreadPool::add_avail(_thread* avail)  
      29. {  
      30.     bool ret = false;  
      31.   
      32.     pthread_mutex_lock(&tp_mutex);  
      33.     if (tp_avail < tp_max)  
      34.     {  
      35.         tp_list[tp_avail] = avail;  
      36.         tp_avail++;          
      37.         pthread_cond_signal(&tp_idle);  //线程池中有线程为空闲  
      38.         if (tp_avail >= tp_total)  
      39.         {  
      40.             pthread_cond_signal(&tp_full); //线程池中所有线程都为为空闲  
      41.         }  
      42.         ret = true;  
      43.     }  
      44.     pthread_mutex_unlock(&tp_mutex);  
      45.       
      46.     return ret;  
      47. }  
      48.   
      49. void* ThreadPool::work_thread(void* args)  
      50. {  
      51.     _thread* thread = (_thread*) args;  
      52.     ThreadPool *pool = thread->parent;  
      53.     while (pool->tp_stop == false)   
      54.     {  
      55.         thread->do_job(thread->args);  
      56.         pthread_mutex_lock(&thread->thread_mutex); //执行完任务之后，添加到空闲线程队列中  
      57.         if (pool->add_avail(thread))  
      58.         {      
      59.             pthread_cond_wait(&thread->thread_cond, &thread->thread_mutex);  
      60.             pthread_mutex_unlock(&thread->thread_mutex);  
      61.         }  
      62.         else  
      63.         {  
      64.             pthread_mutex_unlock(&thread->thread_mutex);  
      65.             pthread_mutex_destroy(&thread->thread_mutex);  
      66.             pthread_cond_destroy(&thread->thread_cond);  
      67.             free(thread);  
      68.             break;  
      69.         }  
      70.     }  
      71.   
      72.     pthread_mutex_lock(&pool->tp_mutex);  
      73.     pool->tp_total--;  
      74.     if (pool->tp_total <= 0)  
      75.     {  
      76.         pthread_cond_signal(&pool->tp_empty);  
      77.     }  
      78.     pthread_mutex_unlock(&pool->tp_mutex);  
      79.   
      80.     return NULL;  
      81. }  
      82.   
      83. bool ThreadPool::add_thread(dispatch_fn dispatch_me, void* args)  //添加一个线程  
      84. {  
      85.     _thread* thread = NULL;  
      86.     pthread_attr_t attr;  
      87.       
      88.     thread = (_thread *) malloc(sizeof(_thread));  
      89.     if (NULL == thread)  
      90.     {  
      91.         return false;  
      92.     }  
      93.   
      94.     pthread_mutex_init(&thread->thread_mutex, NULL);  
      95.     pthread_cond_init(&thread->thread_cond, NULL);  
      96.     thread->do_job = dispatch_me;  
      97.     thread->args = args;  
      98.     thread->parent = this;  
      99.     pthread_attr_init(&attr);  
      100.     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);  
      101.   
      102.     if (pthread_create(&thread->thread_id, &attr, work_thread, (void *) thread) != 0)  
      103.     {  
      104.         pthread_mutex_destroy(&thread->thread_mutex);  
      105.         pthread_cond_destroy(&thread->thread_cond);  
      106.         pthread_attr_destroy(&attr);  
      107.         free(thread);  
      108.         return false;  
      109.     }                  
      110.     tp_total++;  
      111.   
      112.     return true;  
      113. }  
      114.   
      115. void ThreadPool::dispatch_threadpool(dispatch_fn dispatch_me, void* args)  
      116. {  
      117.     _thread* thread = NULL;  
      118.   
      119.     pthread_mutex_lock(&tp_mutex);  
      120.       
      121.     if (tp_avail <= 0 && tp_total >= tp_max) //无可用线程，而且线程数已达最大值，等待空闲线程  
      122.     {  
      123.         pthread_cond_wait(&tp_idle, &tp_mutex);  
      124.     }  
      125.   
      126.     if (tp_avail <= 0)  //无可用线程，而且线程数未达最大值，添加线程  
      127.     {  
      128.         if (!add_thread(dispatch_me, args))  
      129.         {  
      130.             return;  
      131.         }  
      132.     }  
      133.     else   //有可用线程  
      134.     {  
      135.         tp_avail--;  
      136.         thread = tp_list[tp_avail];  
      137.         tp_list[tp_avail] = NULL;          
      138.         thread->do_job = dispatch_me;  
      139.         thread->args = args;  
      140.   
      141.         pthread_mutex_lock(&thread->thread_mutex);  
      142.         pthread_cond_signal(&thread->thread_cond);  
      143.         pthread_mutex_unlock(&thread->thread_mutex);  
      144.     }  
      145.   
      146.     pthread_mutex_unlock(&tp_mutex);  
      147. }  
      148.   
      149.   
      150. void ThreadPool::syn_all()  
      151. {      
      152.     if (tp_avail < tp_total)   //等待线程池中所有线程都为空闲状态  
      153.     {  
      154.         pthread_cond_wait(&tp_full, &tp_mutex);  
      155.     }      
      156.       
      157.     tp_stop = true;      
      158.     int i = 0;      
      159.     for (i = 0; i < tp_avail; i++)  //唤醒线程池中所有线程  
      160.     {  
      161.         _thread *thread = tp_list[i];          
      162.         pthread_mutex_lock(&thread->thread_mutex);  
      163.         pthread_cond_signal(&thread->thread_cond);  
      164.         pthread_mutex_unlock(&thread->thread_mutex);  
      165.     }      
      166.     if (tp_total > 0)  
      167.     {  
      168.         pthread_cond_wait(&tp_empty, &tp_mutex);  //等待线程池中所有线程都结束  
      169.     }  
      170. }  
      171.   
      172. ThreadPool::~ThreadPool()  
      173. {  
      174.     sleep(MANAGE_INTREVAL);  
      175.     pthread_mutex_lock(&tp_mutex);  
      176.     syn_all();                        //等待线程池为空  
      177.     int i = 0;  
      178.     for (i = 0; i < tp_total; i++)  //资源释放  
      179.     {  
      180.         free(tp_list[i]);  
      181.         tp_list[i] = NULL;  
      182.     }  
      183.     pthread_mutex_unlock(&tp_mutex);  
      184.     pthread_mutex_destroy(&tp_mutex);  
      185.     pthread_cond_destroy(&tp_idle);  
      186.     pthread_cond_destroy(&tp_full);  
      187.     pthread_cond_destroy(&tp_empty);  
      188.     free(tp_list);  
      189. }  
  • 相关阅读:
    经典台词
    经典台词
    经典台词
    受限于冷启动
    Random Fourier Features
    Convex optimization 凸优化
    希尔伯特空间
    正交是垂直在数学上的一种抽象化和一般化 两个不同向量正交是指它们的内积为0，这也就意味着这两个向量之间没有任何相关性
    任何函数都可以展开为三角级数
    singular value decomposition
  • 原文地址：https://www.cnblogs.com/zzb-Dream-90Time/p/5773713.html
Copyright © 2011-2022 走看看