线程池的使用场景和代码实现！

前言：

大家周末好，今天给大家带来一篇技术文章，是关于线程池的实现和使用场景;我相信大家在公司里面的代码里面经常看到这个线程池的用法，或者甚至大家可能会听到内存池、对象池、连接池等这些专业术语，反正就很多带池的专业术语，不过你会发现他们都有一个共同的特点就是“屁股”末尾都带一个“池”字，池字，简单理解就是用来存东西的，举个简单例子来说，你比如游泳池里面可以用来存储水!

成都创新互联公司专注于企业成都全网营销推广、网站重做改版、涡阳网站定制设计、自适应品牌网站建设、H5高端网站建设、商城系统网站开发、集团公司官网建设、成都外贸网站建设公司、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为涡阳等各大城市提供网站开发制作服务。

好了简单说了一下，后面的哪些什么内存池、连接池，后期复习都再给大家分享吧，今天我们的主题是线程池。

一、线程池的实现：

1、为啥要用到线程池?

多线程编程，大家这个应该很熟悉了，上次有一位朋友问了一个问题，一个线程大概占用多大内存大小，一般按照POSIX标准来算的话，一个线程大概在8M左右，但是我们一般内存资源有限，在进行高并发的时候，比如说，多个客户端同时向服务器端发送请求：

这个时候，你想一下给这么多客户端都分配开一个大概8M的内存大小，这现实嘛，显然行不通的嘛，我们来计算一下：

  • 一个线程：8M
  • 1024M可以开128个线程
  • 16G内存大小可以开16x128,计算下来大概在2048个线程

所以百万级个客户端都分配开一个线程的话，那内存资源肯定是不够的，所以这涉及到我们的线程池了，这也是为什么在这种场景下要使用线程池了!

为了帮助大家更好的理解线程池这个概念，我们还是举一个生活当中的实际场景吧;去银行存钱或者办理相关业务，这个大家都不陌生吧，你到了银行里面，一般来说的话，都要排队在窗口等待前面的人把业务办理完，才能够轮到你来办理你想要办理的业务，而窗口里面就是帮你办理各种业务的银行工作人员，同时一般窗口办理业务上面有一个提示电子信息，如果轮到了你，就会通知你，你就知道了轮到自己办理业务了。

这里换个专业的角度来说(也不专业哈，只是一个打比方)，你来办理的这个业务就是一个任务(也就是一个线程，可以说成任务队列，因为要排队嘛，不可能一下子执行那么多任务，任务队列里面的任务必须一个一个执行)，而银行工作人员相当于从任务队列里面拿一个任务来执行，你可以把银行工作人员看成是执行任务队列;而电子显示通知信息，你可以把它看成防止多个业务同时在一个窗口让一个银行工作人员来办理，两个窗口也就是两个银行工作人员同时办理一个业务，也就是说这个电子显示信息是一个管理组件，管理任务是否可以去办理，管理着银行工作人员是否开始办理业务任务，不让他们乱套了，合理有效的执行任务。

那么你从上面可以看到，使用线程池的优点了：

  • 避免线程太多，使得内存耗尽
  • 开始的时候，你可以把创建好的线程放入到线程池当中去，当我们要用的时候，就可以从线程池里面拿一个线程来用，用完这个线程的时候，再把这个线程放回到线程池里面;避免创建线程与销毁的代价

2、线程池实现模板步骤：

其实这个线程池的实现大概流程步骤都差不多，如果大家平时仔细看公司代码或者说自己去实现一个线程池的话，大概实现模板如下：

  • 任务队列(前来办理业务的人)
  • 执行队列(就是银行工作人员执行任务队列里面的任务)
  • 管理组件(管理任务有序的执行)

3、线程池实现结构体定义：

任务队列：

 
 
 
 
    
  
  
  
  
  1. struct nTask 
    2. 
  
  
  
  
  2. { 
    3. 
  
  
  
  
  3. //用函数指针来存放不同的任务 
    4. 
  
  
  
  
  4.   void (*task_func)(struct nTask *task); 
    5. 
  
  
  
  
  5.    
    6. 
  
  
  
  
  6.   //这个参数用来做任务执行的参数 
    7. 
  
  
  
  
  7.   void *user_data; 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. //链表节点的定义，这里采用链表的方式实现 
    10. 
  
  
  
  
  10. struct nTask *prev; 
    11. 
  
  
  
  
  11. struct nTask *next; 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13. }; 
    14.
  • 执行队列：
 
 
 
 
    
  
  
  
  
  1. struct nWorker 
    2. 
  
  
  
  
  2. { 
    3. 
  
  
  
  
  3.   pthread_t threadid;//线程id 
    4. 
  
  
  
  
  4.    
    5. 
  
  
  
  
  5.   int terminate;//表示是否终止任务 
    6. 
  
  
  
  
  6.  //表示银行工作人员要执行任务还要向执行组件通告一下 
    7. 
  
  
  
  
  7.   struct nManager *manager; 
    8. 
  
  
  
  
  8.    
    9. 
  
  
  
  
  9.   //还是通过链表的方式来实现执行队列 
    10. 
  
  
  
  
  10.   struct nWorker *prev; 
    11. 
  
  
  
  
  11.   struct nWorker *next; 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13. }; 
    14.

注意：这里如果没有办理业务的人来，银行工作人员只能在哪里等待任务的到来，然后再执行任务。

  • 管理组件：
 
 
 
 
    
  
  
  
  
  1. typedef struct nManager 
    2. 
  
  
  
  
  2. { 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.   struct nTask *task; 
    5. 
  
  
  
  
  5.   struct nWorker *workers; 
    6. 
  
  
  
  
  6.    
    7. 
  
  
  
  
  7.   pthread_mutex_t mutex;//互斥锁 
    8. 
  
  
  
  
  8.   pthread_cond_t cond;//条件变量 
    9. 
  
  
  
  
  9. }ThreadPool; 
    10.
  • 链表的插入和删除模板：
 
 
 
 
    
  
  
  
  
  1. //插入 
    2. 
  
  
  
  
  2. #define LIST_INSERT(item,list) do{\ 
    3. 
  
  
  
  
  3.   item->prev=NULL;                \ 
    4. 
  
  
  
  
  4.   item->next=list;                \ 
    5. 
  
  
  
  
  5. if((list)!=NULL) list->prev=item;\ 
    6. 
  
  
  
  
  6. list=item; 
    7. 
  
  
  
  
  7. }while(0) 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9. //删除 
    10. 
  
  
  
  
  10. #define LIST_REMOVE(item,list) do{ \ 
    11. 
  
  
  
  
  11. if(item->prev != NULL) item->prev->next = item->next; \ 
    12. 
  
  
  
  
  12. if(item->next !=NULL) item->next->prev=item->prev;  \ 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14. if(list == item)list = item->netx; \  
    15. 
  
  
  
  
  15. item->prev=item->next=NULL;\ 
    16. 
  
  
  
  
  16. }while(0) 
    17. 
  
  
  
  
  17.  
    18. 
  
  
  
  
  18. } 
    19.

4、线程池接口定义如下：

1、线程池初始化接口：

 
 
 
 
    
  
  
  
  
  1. int nThreadPoolCreate(ThreadPool *pool,int numWorkers) 
    2. 
  
  
  
  
  2. { 
    3. 
  
  
  
  
  3. //参数pool表示线程池，numWorkers表示线程池里面有多少个任务 
    4. 
  
  
  
  
  4. } 
    5.

2、线程池销毁接口：

 
 
 
 
    
  
  
  
  
  1. int nThreadPoolDestory(ThreadPool *pool,int nWorker) 
    2. 
  
  
  
  
  2. { 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4. } 
    5.

3、往线程池里面添加任务接口：

 
 
 
 
    
  
  
  
  
  1. int nThreadPoolPushTask(ThreadPool *pool,struct nTask *task) 
    2. 
  
  
  
  
  2. { 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. } 
    6.

4、线程回调函数：

 
 
 
 
    
  
  
  
  
  1. void *nThreadPoolCallback(void *arg) 
    2. 
  
  
  
  
  2. { 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5. } 
    6.

二、线程池工程代码：

 
 
 
 
    
  
  
  
  
  1. #include  
    2. 
  
  
  
  
  2. #include  
    3. 
  
  
  
  
  3. #include  
    4. 
  
  
  
  
  4. #include  
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. //链表插入 
    7. 
  
  
  
  
  7. #define LIST_INSTER(item,list)do{ \ 
    8. 
  
  
  
  
  8. item->prev=NULL;       \ 
    9. 
  
  
  
  
  9. item->next=next;       \ 
    10. 
  
  
  
  
  10. if(list!=NULL) list->prev=item; \ 
    11. 
  
  
  
  
  11. list=item; 
    12. 
  
  
  
  
  12. }while(0) 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14. //删除 
    15. 
  
  
  
  
  15. #define LIST_REMOVE(item,list)do {  \ 
    16. 
  
  
  
  
  16. if(item->prev!=NULL)item->prev->next=item->next; \ 
    17. 
  
  
  
  
  17. if(item->next!=NULL)itme->next->prev=item->prev;\ 
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19. if(list==item)list=item->next; 
    20. 
  
  
  
  
  20. item->prev=item->next=NULL; 
    21. 
  
  
  
  
  21. }while(0) 
    22. 
  
  
  
  
  22.  
    23. 
  
  
  
  
  23. //任务队列 
    24. 
  
  
  
  
  24.  
    25. 
  
  
  
  
  25. struct nTask 
    26. 
  
  
  
  
  26. { 
    27. 
  
  
  
  
  27.   void(*task_funt)(struct nTask *task); 
    28. 
  
  
  
  
  28.   void *uset_data; 
    29. 
  
  
  
  
  29.    
    30. 
  
  
  
  
  30.   struct nTask *prev; 
    31. 
  
  
  
  
  31.   struct nTask *next; 
    32. 
  
  
  
  
  32. }; 
    33. 
  
  
  
  
  33.  
    34. 
  
  
  
  
  34. //执行队列 
    35. 
  
  
  
  
  35. struct nWorker 
    36. 
  
  
  
  
  36. { 
    37. 
  
  
  
  
  37.   pthread_t threadid; 
    38. 
  
  
  
  
  38.   int terminate; 
    39. 
  
  
  
  
  39.    
    40. 
  
  
  
  
  40.   struct nManager *manager; 
    41. 
  
  
  
  
  41.    
    42. 
  
  
  
  
  42.   struct nWorker *prev; 
    43. 
  
  
  
  
  43.   struct nWorker *next; 
    44. 
  
  
  
  
  44. }; 
    45. 
  
  
  
  
  45.  
    46. 
  
  
  
  
  46. //管理组件 
    47. 
  
  
  
  
  47. typedef struct nManager 
    48. 
  
  
  
  
  48. { 
    49. 
  
  
  
  
  49.   struct nTask *tasks; 
    50. 
  
  
  
  
  50.   struct nWoker *workers; 
    51. 
  
  
  
  
  51.    
    52. 
  
  
  
  
  52.   pthread_mutex_t mutex; 
    53. 
  
  
  
  
  53.   pthread_cond_t cond; 
    54. 
  
  
  
  
  54.  
    55. 
  
  
  
  
  55. }ThreadPool; 
    56. 
  
  
  
  
  56. //线程回调函数 
    57. 
  
  
  
  
  57. void *nThreadPoolCallback(void *arg) 
    58. 
  
  
  
  
  58. { 
    59. 
  
  
  
  
  59.   struct nWorker *worker=(struct nWorker*)arg; 
    60. 
  
  
  
  
  60.    
    61. 
  
  
  
  
  61.   while(1) 
    62. 
  
  
  
  
  62.   { 
    63. 
  
  
  
  
  63.     //判断是否有任务 
    64. 
  
  
  
  
  64.     pthread_mutex_lock(&worker->manager-mutex); 
    65. 
  
  
  
  
  65.     while(worker->manager->tasks==NULL) 
    66. 
  
  
  
  
  66.     { 
    67. 
  
  
  
  
  67.       if(worker-terminate) 
    68. 
  
  
  
  
  68.         break; 
    69. 
  
  
  
  
  69.       pthread_cond_wait(&worker->manager->cond,&worker->manager->mutex);//如果没有任务，一直等待任务的到来 
    70. 
  
  
  
  
  70.     } 
    71. 
  
  
  
  
  71.     if(worker->terminate) 
    72. 
  
  
  
  
  72.     { 
    73. 
  
  
  
  
  73.       pthread_mutex_unlock(&worker->manager->mutex); 
    74. 
  
  
  
  
  74.       break; 
    75. 
  
  
  
  
  75.      
    76. 
  
  
  
  
  76.     } 
    77. 
  
  
  
  
  77.   struct nTask *task = worker->manager->tasks; 
    78. 
  
  
  
  
  78.   LIST_REMOVE(task,worker->manager->tasks); 
    79. 
  
  
  
  
  79.   pthread_mutex_unlock(&worker->manager->mutex); 
    80. 
  
  
  
  
  80.   task->task_func(task); 
    81. 
  
  
  
  
  81.    
    82. 
  
  
  
  
  82.   } 
    83. 
  
  
  
  
  83.  
    84. 
  
  
  
  
  84. free(worker); 
    85. 
  
  
  
  
  85. } 
    86. 
  
  
  
  
  86.  
    87. 
  
  
  
  
  87. //创建线程池 
    88. 
  
  
  
  
  88. int nThreadPoolCreate(ThreadPool *pool, int numWorkers) 
    89. 
  
  
  
  
  89. { 
    90. 
  
  
  
  
  90.   if(pool == NULL) return -1; 
    91. 
  
  
  
  
  91.   if(numWorkers < 1)numWorkers =1; 
    92. 
  
  
  
  
  92.   memset(&pool,0,sizeof(ThreadPool)); 
    93. 
  
  
  
  
  93.  
    94. 
  
  
  
  
  94.   //开始初始化 
    95. 
  
  
  
  
  95.   pthread_cond_t blank_cond = PTHREAD_COND_INITIALIZER; 
    96. 
  
  
  
  
  96.  
    97. 
  
  
  
  
  97.   memcpy(&pool->cond,&blank_cond,sizeof(pthread_cond_t)); 
    98. 
  
  
  
  
  98.  
    99. 
  
  
  
  
  99.   pthread_mutex_t blank_mutex =PTHREAD_MUTEX_INITIALIZER; 
    100. 
  
  
  
  
  100.   memcpy(&pool->mutex,&blank_mutex,sizeof(pthread_mutex_t)); 
    101. 
  
  
  
  
  101.  
    102. 
  
  
  
  
  102.   int i =0;//开线程的个数,也就是执行任务的个数 
    103. 
  
  
  
  
  103.  
    104. 
  
  
  
  
  104.   for(i=0;i < numWorkers;i++) 
    105. 
  
  
  
  
  105.   { 
    106. 
  
  
  
  
  106.     struct nWorker *worker =(struct nWorker*)malloc(sizeof(struct nWorker)); 
    107. 
  
  
  
  
  107.     if(worker == NUll) 
    108. 
  
  
  
  
  108.     { 
    109. 
  
  
  
  
  109.         perror("malloc"); 
    110. 
  
  
  
  
  110.         return -2; 
    111. 
  
  
  
  
  111.     } 
    112. 
  
  
  
  
  112.     memset(worker,0,sizeof(struct nWorker)); 
    113. 
  
  
  
  
  113.     worker->manager=pool; 
    114. 
  
  
  
  
  114.  
    115. 
  
  
  
  
  115.   //创建线程 
    116. 
  
  
  
  
  116.   int ret=pthread_create(&worker->pthreadid,NULL,nThreadPoolCallback,worker); 
    117. 
  
  
  
  
  117.    
    118. 
  
  
  
  
  118.     if(ret) 
    119. 
  
  
  
  
  119.     { 
    120. 
  
  
  
  
  120.       perror("pthread_create"); 
    121. 
  
  
  
  
  121.       free(worker); 
    122. 
  
  
  
  
  122.       return -3; 
    123. 
  
  
  
  
  123.     } 
    124. 
  
  
  
  
  124.     LIST_INSERT(worker,pool->workers); 
    125. 
  
  
  
  
  125.   } 
    126. 
  
  
  
  
  126. } 
    127. 
  
  
  
  
  127.  
    128. 
  
  
  
  
  128. //线程池销毁 
    129. 
  
  
  
  
  129.  
    130. 
  
  
  
  
  130. int nThreadPoolDestory(ThreadPool *pool,int nWorker) 
    131. 
  
  
  
  
  131. { 
    132. 
  
  
  
  
  132.   struct nWorker *worker = NULL; 
    133. 
  
  
  
  
  133.   for(worker=pool->workers;worker!=NULL;worker=worker->next) 
    134. 
  
  
  
  
  134.   { 
    135. 
  
  
  
  
  135.     worker->terminate; 
    136. 
  
  
  
  
  136.   } 
    137. 
  
  
  
  
  137. pthread_mutex_lock(&pool->mutex); 
    138. 
  
  
  
  
  138. pthread_cond_broadcast(&pool->cond);//做一个广播通知 
    139. 
  
  
  
  
  139. pthread_mutex_unlock(&pool->mutex); 
    140. 
  
  
  
  
  140.  
    141. 
  
  
  
  
  141. pool->workers = NULL; 
    142. 
  
  
  
  
  142. pool->tasks = NULL; 
    143. 
  
  
  
  
  143. } 
    144. 
  
  
  
  
  144.  
    145. 
  
  
  
  
  145. //往线程池里面添加任务 
    146. 
  
  
  
  
  146.  
    147. 
  
  
  
  
  147. int nThreadPoolPushTask(ThreadPool *pool,struct nTask *task) 
    148. 
  
  
  
  
  148. { 
    149. 
  
  
  
  
  149.   pthread_mutex_lock(&pool->mutex); 
    150. 
  
  
  
  
  150.   LIST_INSERTER(task,pool->tasks); 
    151. 
  
  
  
  
  151.   pthread_cond_sigal(&pool->cond);// 发送一个信号，有人来办理业务了 
    152. 
  
  
  
  
  152.   pthread_mutex_unlock(&pool-mutex); 
    153. 
  
  
  
  
  153. } 
    154. 
  
  
  
  
  154.  
    155. 
  
  
  
  
  155.  
    156. 
  
  
  
  
  156. #if 1 
    157. 
  
  
  
  
  157.  
    158. 
  
  
  
  
  158. #define THREADPOOL_INIT_COUNT 20 
    159. 
  
  
  
  
  159. #define TASK_INIT_SIZE   1000 
    160. 
  
  
  
  
  160.  
    161. 
  
  
  
  
  161.  
    162. 
  
  
  
  
  162. void task_entry(struct nTask *task) { //type  
    163. 
  
  
  
  
  163.  
    164. 
  
  
  
  
  164.  //struct nTask *task = (struct nTask*)task; 
    165. 
  
  
  
  
  165.  int idx = *(int *)task->user_data; 
    166. 
  
  
  
  
  166.  
    167. 
  
  
  
  
  167.  printf("idx: %d\n", idx); 
    168. 
  
  
  
  
  168.  
    169. 
  
  
  
  
  169.  free(task->user_data); 
    170. 
  
  
  
  
  170.  free(task); 
    171. 
  
  
  
  
  171. } 
    172. 
  
  
  
  
  172.  
    173. 
  
  
  
  
  173.  
    174. 
  
  
  
  
  174. int main(void) { 
    175. 
  
  
  
  
  175.  
    176. 
  
  
  
  
  176.  ThreadPool pool = {0}; 
    177. 
  
  
  
  
  177.   
    178. 
  
  
  
  
  178.  nThreadPoolCreate(&pool, THREADPOOL_INIT_COUNT); 
    179. 
  
  
  
  
  179.  // pool --> memset(); 
    180. 
  
  
  
  
  180.   
    181. 
  
  
  
  
  181.  int i = 0; 
    182. 
  
  
  
  
  182.  for (i = 0;i < TASK_INIT_SIZE;i ++) { 
    183. 
  
  
  
  
  183.   struct nTask *task = (struct nTask *)malloc(sizeof(struct nTask)); 
    184. 
  
  
  
  
  184.   if (task == NULL) { 
    185. 
  
  
  
  
  185.    perror("malloc"); 
    186. 
  
  
  
  
  186.    exit(1); 
    187. 
  
  
  
  
  187.   } 
    188. 
  
  
  
  
  188.   memset(task, 0, sizeof(struct nTask)); 
    189. 
  
  
  
  
  189.  
    190. 
  
  
  
  
  190.   task->task_func = task_entry; 
    191. 
  
  
  
  
  191.   task->user_data = malloc(sizeof(int)); 
    192. 
  
  
  
  
  192.   *(int*)task->user_data  = i; 
    193. 
  
  
  
  
  193.  
    194. 
  
  
  
  
  194.    
    195. 
  
  
  
  
  195.   nThreadPoolPushTask(&pool, task); 
    196. 
  
  
  
  
  196.  } 
    197. 
  
  
  
  
  197.  
    198. 
  
  
  
  
  198.  getchar(); 
    199. 
  
  
  
  
  199.   
    200. 
  
  
  
  
  200. } 
    201.

代码量稍微有点多，大家可以多多看看几遍!

本文转载自微信公众号「txp玩Linux」，可以通过以下二维码关注。转载本文请联系txp玩Linux公众号。

文章标题：线程池的使用场景和代码实现！
URL标题：http://www.shufengxianlan.com/qtweb/news6/114806.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

企业网站制作知识

分类信息网站

成都网站托管　　 　中国西部信息中心　　 　崇州湖霆科技　　 　梓潼网站建设　　 　软文推广　　 　成都翻译公司　　 　电信机房托管　　 　微信小程序　　 　西云服务器托管　　 　简阳电信机房　　 　格蓝特设备　　 　达州做网站　　 　成都展柜设计　　 　网站收录　　 　广安做网站　　 　鸿程源茂　　 　成都艾瑞格　　 　蜀锦在线　　 　全网整合营销推广　　 　成都制作网站