• Linux系统编程系列之线程池

     Linux系统编程系列（16篇管饱，吃货都投降了！）

            1、Linux系统编程系列之进程基础

            2、Linux系统编程系列之进程间通信(IPC)-信号

            3、Linux系统编程系列之进程间通信(IPC)-管道

            4、Linux系统编程系列之进程间通信-IPC对象

            5、Linux系统编程系列之进程间通信-消息队列

            6、Linux系统编程系列之进程间通信-共享内存

            7、Linux系统编程系列之进程间通信-信号量组

            8、Linux系统编程系列之守护进程

            9、Linux系统编程系列之线程

            10、Linux系统编程系列之线程属性 

            11、Linux系统编程系列之互斥锁和读写锁

            12、Linux系统编程系列之线程的信号处理

            13、Linux系统编程系列之POSIX信号量

            14、Linux系统编程系列之条件变量

            15、Linux系统编程系列之死锁

            16、 Linux系统编程系列之线程池

    一、什么是线程池

            线程池就是将许多线程，放置在一个池子中（实际就是一个结构体），只要有任务，就将任务投入池中，这些线程们通过某些机制，及时处理这些任务，一旦处理完后又重新回到池子中重新接收新任务。为了便于管理，线程池还应当提供诸如初始化线程池，增删线程数量，检测未完成任务的数据，检测正在执行任务的线程的数量、销毁线程池等等基本操作。

    二、特性

            1、更好的满足并发性需求

            2、更加节省系统资源，降低负载

            3、避免每次需要执行任务时都创建新的线程

            4、可以限制并发线程数量，帮助控制应用程序的性能和稳定性

            核心思想：通过精巧的设计使得池子中的线程数量可以动态地发生变化，让线程既可以应对并发性需求，又不会浪费系统资源

    三、使用场景

            用来应对某种场景，要在程序中创建大量线程，并且这些线程的数量和生命周期均不确定，可能方生方死，也可能常驻内存，请看下面举例。

            1、处理大量密集型任务

            线程池可以处理多个任务，从而减少了创建和销毁线程的开销，提高了系统性能

            2、服务端应用程序

            线程池可以帮助服务端应用程序同时处理多个客户端请求

            3、I/O 密集型应用程序

            线程池可以处理 I/O 操作，允许系统使用空闲时间进行其他任务处理

            4、Web 应用程序

            线程池可以处理来自 Web 客户端的请求，从而提高了 Web 应用程序的性能

            总之，任何需要处理大量任务或需要同时处理多个请求的应用程序都可以使用线程池来提高性能和效率。

    四、设计思想

            设计某个东西一定要有个目标，这里是要求设计一个线程池，首先要明白线程池的作用，然后根据其作用来展开设计。线程池是通过让线程的数量进行动态的变化来及时处理接受的任务，所以核心就是线程和任务。可以将问题转换为如何组织线程和组织任务？借鉴别人的一幅图

             1、如何组织线程

                    从上图可以看出，线程被创建出来之后，都处于睡眠态，它们实际上是进入了条件变量的等待队列中，而任务都被放入一个链表，被互斥锁保护起来

                    线程的生命周期如下：（这里省略程序执行的流程图）

                    （1）、线程被创建

                    （2）、预防死锁，准备好退出处理函数，防止在持有一把锁的状态中死去

                    （3）、尝试持有互斥锁（等待任务）

                    （4）、判断是否有任务，若无则进入条件变量等待队列睡眠，若有则进入第（5）步

                    （5）、从任务链表中取得一个任务

                    （6）、释放互斥锁

                    （7）、弹出退出处理函数，避免占用内存

                    （8）、执行任务

                    （9）、执行任务完成后重新回到第（2）步

                    线程的生命周期其实就是线程要做的事情，把上面的第（2）步到第（8）步写成一个线程的例程函数。

             2、如何组织任务

                    所谓的任务就是一个函数，回想一下创建一条线程时，是不是要指定一个线程例程函数。这里的线程池做法是将函数（准确的说是函数指针）及其参数存入一个任务节点，并将节点链接成一个链表。所以现在的问题变成如何设计一个任务链表？

                    一个链表的操作有：创建节点，增加节点，删除节点，查询节点这几步。由于这里是任务节点，就不需要查询了，当然也可以查询。所以现在的问题转换为任务节点如何设计？

                    任务节点的数据域主要有函数指针和函数参数，指针域就是一个简单任务结点指针，也可以是双向循环链表。

                    设计分析到这里，基本上有了框架了，前面买了这么多关子，下面就来个重头戏。其实前面主要是想描述一种设计思想，遇到新的东西如何设计它？首先要明白设计的目的和作用，然后找出核心点，最后就是把核心点进行不断的分析推理，一步步转换为最基本的问题。学过项目管理的同学应该听过在范围管理里有个叫工作分解结构的东西，这里跟那个差不多。

    五、案例

            实现一个线程池，并完成线程池的基本操作演示

            thread_pool.h（线程池头文件）

    1. #ifndef _THREAD_POOL_H
    2. #define _THREAD_POOL_H
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9.  
    10. #define MAX_WAITING_TASKS	1000    // 最大的等待任务数量
    11. #define MAX_ACTIVE_THREADS	20      // 最多的活跃线程数量
    12.  
    13. // 任务节点
    14. typedef struct task 
    15. {
    16.     void *(*do_task) (void *arg);   // 函数指针
    17.     void *arg;      // 函数参数
    18.     struct task *next;  // 指向下一个任务节点
    19. }task;
    20.  
    21.  
    22. // 线程池的管理节点
    23. typedef struct thread_pool
    24. {
    25.     pthread_mutex_t task_list_lock;   // 任务列表互斥锁，保证同一个时间只有一条线程进行访问
    26.     pthread_cond_t  task_list_cond;   // 任务列表条件变量，保证没有任务时，线程进入睡眠
    27.  
    28.     task *task_list;    // 任务列表
    29.  
    30.     pthread_t *tids;     // 存放线程号的数组
    31.  
    32.     int shutdown;  // 线程池销毁的开关
    33.  
    34.     unsigned int max_waiting_tasks;  // 最大等待的任务数量
    35. 	unsigned int waiting_tasks;      // 正在等待被处理的任务数量
    36. 	unsigned int active_threads;     // 正在活跃的线程数
    37.  
    38. }thread_pool;
    39.  
    40. // 初始化线程池
    41. int init_pool(thread_pool *pool, unsigned int threads_number);
    42.  
    43. // 往线程池中添加任务
    44. int add_task(thread_pool *pool, void *(*do_task)(void *arg), void *arg);
    45.  
    46. // 往线程池中添加线程
    47. int add_thread(thread_pool *pool, unsigned int additional_threads);
    48.  
    49. // 从线程池中删除线程
    50. int remove_thread(thread_pool *pool, unsigned int removing_threads);
    51.  
    52. // 查询线程池中线程数量
    53. int total_thread(thread_pool *pool);
    54.  
    55. // 销毁线程池
    56. int destroy_pool(thread_pool *pool);
    57.  
    58. // 线程的例程函数
    59. void *routine(void *arg);
    60.  
    61. #endif // _THREAD_POOL_H

            thread_pool.c（线程池实现文件） 

    1. #include "thread_pool.h"
    2.  
    3. // 初始化线程池
    4. int init_pool(thread_pool *pool, unsigned int threads_number)
    5. {
    6.     if(threads_number < 1)
    7.     {
    8.         printf("warning: threads_number must bigger than 0\n");
    9.         return -1;
    10.     }
    11.     if(threads_number > MAX_ACTIVE_THREADS)
    12.     {
    13.         printf("warning: threads number is bigger than MAX_ACTIVE_THREADS(%u)\n", MAX_ACTIVE_THREADS);
    14.         return -1;
    15.     }
    16.  
    17.     pthread_mutex_init(&pool->task_list_lock, NULL); // 初始化互斥锁
    18.     pthread_cond_init(&pool->task_list_cond, NULL);  // 初始化条件变量
    19.  
    20.     pool->task_list = calloc(1, sizeof(task));  // 申请一个任务头节点
    21.     if(!pool->task_list)
    22.     {
    23.         printf("error: task_list calloc fail\n");
    24.         return -1;
    25.     }
    26.     pool->task_list->next = NULL;   // 让任务头节点指向NULL
    27.  
    28.     pool->tids = calloc(MAX_ACTIVE_THREADS, sizeof(pthread_t)); // 申请堆数组用来存放线程号
    29.     if(!pool->tids)
    30.     {
    31.         printf("error: tids calloc fail\n");
    32.         return -1;
    33.     }
    34.  
    35.     pool->shutdown = 0; // 关闭线程池销毁开发
    36.  
    37.     pool->waiting_tasks = 0;    // 当前等待任务为0
    38.     pool->max_waiting_tasks = MAX_WAITING_TASKS;    // 初始化最大等待任务数量
    39.     pool->active_threads = threads_number;  // 初始化活跃的线程数
    40.    
    41.     // 根据活跃的线程数，创建对应数量的线程
    42.     for(int i = 0; i < pool->active_threads; i++)
    43.     {
    44.         // 需要判断线程是否创建失败
    45.         // 线程号用线程号数组，线程属性设置为默认的，例程函数是routine，函数参数是线程池
    46.         errno = pthread_create(&pool->tids[i], NULL, routine,(void*)pool);
    47.         if(errno != 0)
    48.         {
    49.             perror("error: pthread_create fail");
    50.             return -1;
    51.         }
    52.     }
    53.     
    54.     return 1;
    55. }
    56.  
    57. // 往线程池中添加任务
    58. int add_task(thread_pool *pool, void *(*do_task)(void *arg), void *arg)
    59. {
    60.     if(!pool)
    61.     {
    62.         printf("warning: thread_pool is null\n");
    63.         return -1;
    64.     }
    65.  
    66.     // 如果当前等待执行的任务数超过最大等待的任务数量，则退出
    67.     if(pool->waiting_tasks >= pool->max_waiting_tasks)
    68.     {
    69.         printf("warning: task_list is full, too many list\n");
    70.         return -1;
    71.     }
    72.  
    73.     // 尝试给新的任务节点申请空间
    74.     task *new_task = (task*)malloc(sizeof(task));
    75.     if(!new_task)
    76.     {
    77.         printf("error: task malloc fail\n");
    78.         return -1;
    79.     }
    80.  
    81.     // 初始化任务节点
    82.     new_task->do_task = do_task;
    83.     new_task->arg = arg;
    84.     new_task->next = NULL;
    85.  
    86.     // 把任务节点添加到任务列表最后面
    87.     // 1、上锁
    88.     pthread_mutex_lock(&pool->task_list_lock);
    89.     
    90.     // 2、先找到任务列表末尾
    91.     task *tmp = NULL;
    92.     for(tmp = pool->task_list; tmp->next; tmp = tmp->next);
    93.  
    94.     // 3、添加新任务到任务列表末尾，同时当前等待任务数+1
    95.     tmp->next = new_task;
    96.     pool->waiting_tasks++;
    97.  
    98.     // 4、解锁
    99.     pthread_mutex_unlock(&pool->task_list_lock);
    100.  
    101.     // 唤醒一个正在条件变量中睡眠等待的线程，取执行任务
    102.     pthread_cond_signal(&pool->task_list_cond);
    103.  
    104.     return 1;
    105. }
    106.  
    107. // 往线程池中添加线程，返回实际添加的线程数量
    108. int add_thread(thread_pool *pool, unsigned int additional_threads)
    109. {
    110.     if(!pool)
    111.     {
    112.         printf("warning: thread_pool is null\n");
    113.         return -1;
    114.     }
    115.  
    116.     if(additional_threads == 0)
    117.     {
    118.         return 0;
    119.     }
    120.  
    121.     // 期望活跃的线程数 = 目前活跃的线程数 + 期望添加的线程数
    122.     unsigned int total_threads = pool->active_threads + additional_threads;
    123.  
    124.     // 如果超过最大的活跃线程数就打印警告
    125.     if(total_threads > MAX_ACTIVE_THREADS)
    126.     {
    127.         printf("warning: add too many threads\n");
    128.     }
    129.  
    130.     int actual_add_threads = 0;
    131.     for(int i = pool->active_threads; i < total_threads && i < MAX_ACTIVE_THREADS; i++)
    132.     {
    133.         // 需要判断线程是否创建失败
    134.         // 线程号用线程号数组，线程属性设置为默认的，例程函数是routine，函数参数是线程池
    135.         errno = pthread_create(&pool->tids[i], NULL, routine,(void*)pool);
    136.         if(errno != 0)
    137.         {
    138.             perror("error: pthread_create fail");
    139.             
    140.             // 如果一个都没有创建成功，就直接返回
    141.             if(actual_add_threads == 0)
    142.             {
    143.                 return -1;
    144.             }
    145.             // 如果成功创建了多个线程，但是本次创建失败，就跳出循环
    146.             break;
    147.         }
    148.         else
    149.         {
    150.             actual_add_threads++;   // 线程创建成功就+1
    151.         }
    152.     }
    153.  
    154.     // 更新线程池中活跃的线程数
    155.     pool->active_threads += actual_add_threads;
    156.  
    157.     return actual_add_threads;  // 返回实际添加的线程
    158. }
    159.  
    160. // 从线程池中删除线程，返回实际删除线程的数量
    161. int remove_thread(thread_pool *pool, unsigned int removing_threads)
    162. {
    163.     if(!pool)
    164.     {
    165.         printf("warning: thread_pool is null\n");
    166.         return -1;
    167.     }
    168.  
    169.     if(removing_threads == 0)
    170.     {
    171.         return pool->active_threads;
    172.     }
    173.  
    174.     // 如果要删除的线程数大于线程池中活跃的线程数，则打印警告
    175.     if(removing_threads >= pool->active_threads)
    176.     {
    177.         printf("warning: remove too many threads\n");
    178.     }
    179.  
    180.     // 剩余数量 = 活跃数量 - 删除的目标数  
    181. 	int remaining_threads = pool->active_threads - removing_threads;
    182.  
    183. 	//  目的是为了让线程池中最少保留有一个线程可以用于执行任务
    184. 	remaining_threads = remaining_threads > 0 ? remaining_threads : 1;
    185.  
    186.     int actual_remove_threads = 0;;
    187.     // 循环取消线程直到等于期望线程数
    188.     for(int i = pool->active_threads-1; i > remaining_threads-1; i--)
    189.     {
    190.         errno = pthread_cancel(pool->tids[i]);
    191.         if(errno != 0)
    192.         {
    193.             printf("[%ld] cancel error: %s\n", pool->tids[i], strerror(errno));
    194.             break;
    195.         }
    196.         else
    197.         {
    198.             actual_remove_threads++;
    199.         }
    200.     }
    201.  
    202.     // 更新线程池中活跃的线程数量
    203.     pool->active_threads -= actual_remove_threads;
    204.  
    205.     return actual_remove_threads;   // 返回实际删除的线程
    206. }
    207.  
    208. // 查询线程池中线程数量
    209. int total_thread(thread_pool *pool)
    210. {
    211.     return pool->active_threads;
    212. }
    213.  
    214. // 销毁线程池
    215. int destroy_pool(thread_pool *pool)
    216. {
    217.     if(!pool)
    218.     {
    219.         printf("warning: thread_pool is null\n");
    220.         return -1;
    221.     }
    222.  
    223.     pool->shutdown = 1; // 启动线程池销毁开关
    224.  
    225.     pthread_cond_broadcast(&pool->task_list_cond);    // 唤醒所有在线程池中的线程
    226.  
    227.     // 循环等待所有线程退出
    228.     for(int i = 0; i < pool->active_threads; i++)
    229.     {
    230.         errno = pthread_join(pool->tids[i], NULL);
    231.         if(errno != 0)
    232.         {
    233.             printf("join tids[%d] error: %s\n", i, strerror(errno));
    234.         }
    235.         else
    236.         {
    237.             printf("[%ld] is joined\n", pool->tids[i]);
    238.         }
    239.     }
    240.  
    241.     // 先上锁
    242.     pthread_mutex_lock(&pool->task_list_lock);
    243.     // 头删法，从头一个个的删除任务节点
    244.     for(task *p = pool->task_list->next; p; p = pool->task_list)
    245.     {
    246.         pool->task_list->next = p->next;    // 修改首元节点
    247.         free(p);
    248.     }
    249.  
    250.     free(pool->task_list);
    251.     pool->task_list = NULL; // 安全保证
    252.  
    253.     // 解锁
    254.     pthread_mutex_unlock(&pool->task_list_lock);
    255.  
    256.     free(pool->tids);
    257.     free(pool);
    258.     pool->tids = NULL;  // 安全保证
    259.     pool = NULL;    // 安全保证
    260.  
    261.     return 1;
    262. }
    263.  
    264. // 线程的取消函数
    265. void pthread_cancel_handler(void *arg)
    266. {
    267.     printf("[%ld] is cancel\n", pthread_self());
    268.  
    269.     pthread_mutex_unlock((pthread_mutex_t*)arg);    // 解锁
    270. }
    271.  
    272. // 线程的例程函数
    273. void *routine(void *arg)
    274. {
    275.     task *task_p;   // 任务指针，用来执行将要执行的任务
    276.  
    277.     thread_pool *pool = (thread_pool*)arg;
    278.  
    279.     while(1)
    280.     {
    281.         pthread_cleanup_push(pthread_cancel_handler, (void*)&pool->task_list_lock);
    282.  
    283.         // 尝试持有互斥锁
    284.         pthread_mutex_lock(&pool->task_list_lock);
    285.  
    286.         // 判断是否有任务，没有则进入睡眠
    287.         // 1、没有任务，线程池销毁开关断开，则进入条件变量等待队列
    288.         while(!pool->waiting_tasks && !pool->shutdown)
    289.         {
    290.             // 当条件不满足时，会先自动解锁pool->lock，然后等待到条件满足后，会自动上锁pool->lock
    291.             pthread_cond_wait(&pool->task_list_cond, &pool->task_list_lock);
    292.         }
    293.  
    294.         // 2、线程池销毁开发闭合，不管有没有任务，先解锁，然后退出，准备销毁线程池
    295.         if(pool->shutdown)
    296.         {
    297.             pthread_mutex_unlock(&pool->task_list_lock);  // 需要解锁
    298.             pthread_exit(NULL);
    299.         }
    300.  
    301.         // 3、有任务，线程池销毁开关断开，则取一个任务
    302.         if(pool->waiting_tasks && !pool->shutdown)
    303.         {
    304.             task_p = pool->task_list->next;
    305.             pool->task_list->next = task_p->next; // 弹出第一任务节点 
    306.             pool->waiting_tasks--;  // 当前等待的任务数量-1,
    307.  
    308.             pthread_mutex_unlock(&pool->task_list_lock);  // 解锁
    309.         }
    310.         
    311.         // 弹出压入的线程取消函数，运行到这里不执行，但是当线程在前面被意外取消或中断会执行
    312.         pthread_cleanup_pop(0); 
    313.  
    314.         // 为了防止死锁，执行任务期间不接受线程取消请求
    315.         pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
    316.  
    317.         (task_p->do_task)(task_p->arg); // 通过函数指针的方式执行任务
    318.  
    319.         // 执行完任务后，接受线程取消请求
    320.         pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
    321.  
    322.         free(task_p);   // 删除任务节点
    323.         task_p = NULL;  // 安全保证
    324.     }
    325.  
    326.     pthread_exit(NULL);
    327. }

            main.c（线程池操作演示文件） 

    1. // 线程池的测试案例
    2.  
    3. #include 
    4. #include 
    5. #include "thread_pool.h"
    6.  
    7. void *mytask(void *arg)
    8. {	
    9.     int n = rand()%10;
    10.  
    11. 	printf("[%ld][%s] ==> job will be done in %d sec...\n", pthread_self(), __FUNCTION__, n);
    12.     
    13. 	sleep(n);
    14.  
    15. 	printf("[%ld][%s] ==> job done!\n", pthread_self(), __FUNCTION__);
    16. }
    17.  
    18. void *func(void *arg )
    19. {
    20. 	printf("this is a test by [%s]\n", (char*)arg);
    21. 	sleep(1);
    22. 	printf("test finish...\n");
    23. }
    24.  
    25. void *count_time(void *arg)
    26. {
    27. 	int i = 0;
    28. 	while(1)
    29. 	{
    30. 		sleep(1);
    31. 		printf("sec: %d\n", ++i);
    32. 	}
    33. }
    34.  
    35. int main(void)
    36. {
    37. 	pthread_t a;
    38. 	pthread_create(&a, NULL, count_time, NULL);
    39.  
    40. 	// 1、初始化线程池
    41. 	thread_pool *pool = malloc(sizeof(thread_pool));
    42. 	init_pool(pool, 2);
    43.  
    44. 	// 2、投放任务
    45. 	printf("throwing 3 tasks...\n");
    46. 	add_task(pool, mytask, NULL);
    47. 	add_task(pool, mytask, NULL);
    48. 	add_task(pool, mytask, NULL);
    49.  
    50. 	// 3、查看当前线程池中的线程数量
    51. 	printf("current thread number: %d\n", total_thread(pool));
    52. 	sleep(9);
    53.  
    54. 	// 4、再次投放任务
    55. 	printf("throwing another 2 tasks...\n");
    56. 	add_task(pool, mytask, NULL);
    57. 	add_task(pool, mytask, NULL);
    58. 	add_task(pool, func, (void *)"Great Macro");
    59.  
    60. 	// 5、添加2条线程
    61.     printf("try add 2 threads, actual add %d\n", add_thread(pool, 2));
    62.     printf("current thread number: %d\n", total_thread(pool));
    63. 	
    64. 	sleep(5);
    65.  
    66. 	// 6、删除3条线程
    67. 	printf("try remove 3 threads, actual remove: %d\n", remove_thread(pool, 3));
    68.     printf("current thread number: %d\n", total_thread(pool));
    69.  
    70.     sleep(5);
    71. 	// 7、 销毁线程池
    72.     printf("destroy thread pool\n");
    73. 	destroy_pool(pool);
    74. 	return 0;
    75. }

            注：编译时，把线程池文件和测试文件放在同一个工作目录下。

            实际使用时，只需要把thread_pool.h和thread_pool.c拷贝到自己的工程目录下，然后根据规则操作线程池。

    六、总结

            线程池是许多线程的集合，它不是线程组。线程池适用于任何需要处理大量任务或需要同时处理多个请求的应用程序的场景，可以提供性能和效率。

            至此，Linux系统编程系列，16篇完结撒花，历时5天，这年中秋国庆没有假放！！！

  • 相关阅读:
    Flv.js编译使用
    Android MQTT连接阿里云使用Json解析数据
    机器学习笔记 - CRAFT(文本检测的字符区域感知)论文解读
    deepar,传统概率模型如何和深度学习结合的?
    【C语言】strcpy等string函数和memcpy等memory函数的实现，经典方法
    如何查看mysql的存储引擎
    【Vue框架】vue组件的生命周期
    springboot篮球论坛系统springboot034
    esp32 Micropython 使用多线程驱动EC11编码器
    高频react面试题自检
  • 原文地址：https://blog.csdn.net/AABond/article/details/133419014