Linux高性能编程-线程池-51CTO.COM

今天我们来学习Linux线程池，线程池是高并发场景必须具备的软件组件，很多开源项目都会使用线程池，话不多说，直接开始。

1.线程池简介

1.1 什么是线程池？

线程池就是提前创建好一批线程，通过一个池子来管理所有的线程。当有任务时，从池子中取出一个线程去执行该任务，执行结束后，线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。

我们通过几个图来讲解一下线程池的作用。

1）常规多线程

图片

常规多线程方式，每个任务都会创建一个新的线程来处理，任务处理完后线程会销毁。

优点：在任务量比较少的情况下，任务执行效率比较高。

缺点：1.随着任务量增多，线程数量会越来越多，线程开销（CPU，内存开销）很大，如果不控制线程数量，系统会出现异常。2.缺乏任务管理机制。3.缺乏多线程管理机制。

2）简单的线程池

图片

简单线程池通过任务队列和线程池完成。

新任务产生后存储在任务队列，线程池中的空闲线程从任务队列获取任务并执行。

优点：1.线程数量可控，能够保证系统安全。2.任务和线程统一管理，方便程序设计。

缺点：1.没有任务拒绝机制，任务会堆积在任务队列。2.线程池线程数量固定，无法动态调节线程数量，导致任务处理效率不高。

3）完善的线程池

图片

完善的线程池需要具备一下几个优点：

多线程动态管理。
任务实时响应。
高并发安全保护机制。

线程池被分为核心线程和动态线程，核心线程会一直运行保证基础业务，当任务越来越多的时候，核心线程无法保证任务快速响应，此时需要通过创建动态线程提高线程响应速度。

当动态线程到达极限时，系统的处理能力到达瓶颈，此时需要启动安全保护机制，通过任务拒绝，保证系统安全。

1.2 线程池优点

通过上述分析，我们了解到线程池有以下优点：

降低开销：线程池通过重用已存在的线程，降低了线程的创建和销毁所带来的开销，提高了性能。
控制并发数：线程池能够有效控制同时执行的线程数量，防止因线程过多导致系统资源耗尽或性能下降，提高系统稳定性。
提高响应速度：由于线程池中的线程可以复用，减少了线程创建的时间，因此提高了任务的响应速度。
提供丰富功能：线程池不仅可以执行普通任务，还提供定时执行、定期执行、单线程执行以及并发数控制等高级功能，使得线程的管理和使用更加灵活和高效。

2.线程池设计

2.1 整体设计

设计一个完善的线程池，我们需要设计几个核心模块：状态管理、线程管理，任务管理。

状态管理：管理线程池的生命周期。
线程管理：管理核心线程和动态线程。
任务管理：管理任务申请，任务拒绝以及任务高效调度。

2.2 详细设计

线程池定义（struct thread_pool）：

typedef struct thread_pool {
    struct list_head head;   //任务队列
    int task_max; //任务队列最大长度
    int task_num; //任务队列实际长度
    int core_num; //核心线程数量
    int dyn_max; //动态线程最大数量
    atomic_int dyn_num; //动态线程实际数量
    pthread_t *core_th; //核心线程pthread_t数组
    pthread_t *dyn_th; //动态线程pthread_t数组
    int status; //线程池状态
    pthread_mutex_t mutex; //互斥锁
    pthread_cond_t cond; //条件变量
} thread_pool_t;1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

线程池通过struct thread_pool结构体定义，每个成员的作用已在代码中注释。

创建线程池：

thread_pool_t* thread_pool_create(int core_num, int dyn_max) {
    thread_pool_t *tp = (thread_pool_t *)malloc(sizeof(thread_pool_t));
    if (!tp) return NULL;

    pthread_mutex_init(&tp->mutex, NULL);
    pthread_cond_init(&tp->cond, NULL);
    list_head_init(&tp->head);
    tp->status = INIT_STATUS;

    tp->task_max = TASK_MAX;
    tp->task_num = 0;
    tp->dyn_max = dyn_max;
    atomic_init(&tp->dyn_num, 0);
    tp->core_num = core_num;
    tp->core_th = malloc(core_num * sizeof(pthread_t));
    for (int i = 0; i < tp->core_num; i++) { //创建核心线程
        thread_arg *th_arg = (thread_arg *)malloc(sizeof(thread_arg));
        *th_arg = (thread_arg) {.tp = tp, .type = CORE_THREAD, .task = NULL};
        pthread_create(&tp->core_th[i], NULL, thread_proc, (void *)th_arg);
    }

    tp->status = RUNNING_STATUS; //设置线程池为running状态

    return tp;
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.

线程池创建时会指定核心线程数量以及最大动态线程数量，核心线程跟着线程池一起创建。

动态线程根据实际任务量动态创建，为了防止创建过多的动态线程，需限制动态线程最大数量。

销毁线程池：

void thread_pool_destroy_p(thread_pool_t **ptp) {
    if (!ptp) return;
    thread_pool_t *tp = *ptp;

    while(atomic_load(&tp->dyn_num)) { //等待动态线程全部退出
        usleep(10 * 1000);
    }

    for (int i = 0; i < tp->core_num; i++) { //等待核心线程全部退出
        pthread_join(tp->core_th[i], NULL);
    }

    free(tp->core_th);
    pthread_mutex_destroy(&tp->mutex);
    pthread_cond_destroy(&tp->cond);
    tp->status = STOP_STATUS; //设置线程池为stop状态

    free(tp);
    ptp = NULL;
    return;
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.

线程池销毁需要回收核心线程和动态线程，核心线程采用pthread_join方式回收。

动态线程设置分离属性，线程池成员dyn_num（原子变量）用于记录仍在工作的动态线程数量，dyn_num等于0时表示当前所有的动态线程都已经退出。

2.2.1 状态管理

线程池整个生命周期可分为4个状态：

#define INIT_STATUS (1<<0) //init状态
#define RUNNING_STATUS (1<<1) //running状态
#define SHUTDOWN_STATUS (1<<2) //shutdown状态
#define STOP_STATUS (1<<3) //stop状态1.
2.
3.
4.

init状态：线程池创建时的状态，init状态线程不能处理任务。
running状态：线程池初始化完毕后设置为running状态，此时线程池能够提取任务并执行。
shutdown状态：线程池正常或者异常退出，设置为shutdown状态，此时线程池能继续处理工作队列中剩余任务，但无法再接收新的任务。
stop状态：线程池所有线程全部释放，线程池被销毁。

2.2.2 线程管理

核心线程和动态线程处理函数：

void *thread_proc(void *arg) {
    thread_arg *th_arg = (thread_arg *)arg;
    thread_pool_t *tp = th_arg->tp;
    pid_t tid = gettid();
     //动态线程设置成分离模式，方便管理 
     if (th_arg->type == DYN_THREAD) pthread_detach(pthread_self());

    int count = 0;
    task_t *task = NULL;
    while(1) {
        if (th_arg->task) { //创建线程并执行首次任务
            printf("tid:%d first process task\n", tid);
            task = th_arg->task;
            th_arg->task = NULL;
        } else {
            task = thread_get_task(tp); //从任务队列中获取任务并执行
            if (!task) {
                if (tp->status != RUNNING_STATUS) break; //线程池被关闭，线程退出
                count++;
                if ((count >= 10) && (th_arg->type == DYN_THREAD)) {
                    printf("dyn thread 10s break\n");
                    break; //动态线程空闲10秒自动退出
                }
                continue;
            }
            count = 0;
        }
        task->cb(task->arg);
        task_freep(&task);
    }

    free(th_arg);
    if (th_arg->type == DYN_THREAD) {
        atomic_fetch_sub(&tp->dyn_num, 1);
     }
    return NULL;
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.

1）核心线程

核心线程数量固定，在线程池创建时会创建所有的核心线程，线程池退出时会销毁所有的核心线程。

2）动态线程

动态线程的管理比较复杂，需要根据任务数量做动态调整，任务量大时，动态线程会被创建，提高线程池任务响应速率，任务量小时，空闲的动态线程会被回收，从而减少线程开销。

2.2.3 任务管理

任务定义（struct task）：

typedef enum TASK_TYPE {
    FREE_TYPE,
    NOFREE_TYPE,
}TASK_TYPE;

typedef void (*func)(void *arg);
typedef struct task {
    struct list_head list; //队列节点
    func cb; //回调函数
    void *arg; //回调函数参数
    TASK_TYPE type; //任务参数是否需要释放
}task_t;1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

任务通过struct task定义，任务主要成员：

list：队列节点，用于插入和移除任务队列。
cb：回调函数，任务处理函数。
arg：回调函数参数。
type：回调函数参数是否需要释放标志。

任务申请流程如下图，创建一个新的任务后，需要做一些检测才能将任务加入线程池，检测不通过则执行任务拒绝，从而保证线程池始终处于安全高效运行状态。

任务执行完毕后，需释放任务，回收资源。

图片

线程池一定要做任务管理，任务管理的目的有两个：

保证线程池安全，不会堆积过多任务，消耗CPU和内存资源。
提高任务处理效率。

3.线程池测试

测试环境：树莓派4B，4核，4GB。

分别采用多线程和线程池方式测试CPU密集型和IO密集型任务，对比两种方式性能和效率的差异。每毫秒产生1个任务，总共测试10000个任务。

通过time命令执行测试程序，记录测试程序执行情况。

测试代码如下：

（完整代码请联系博主获取）

#define CORE_THREAD_NUM (4) //核心线程数量
#define DYN_THREAD_MAX (32) //动态线程最大数量
#define TASK_MAX (128) //任务队列任务最大数量

#define ENABLE_THREAD_POOL (0) //是否开启线程池，0：关闭 1：开启
#define TEST_TASK_NUM (10000) //测试任务数量
#define TASK_INTERVAL (1000) //任务产生间隔时间，单位：毫秒

#define TEST_TASK_TYPE (0) //任务类型，0：CPU密集型 1：IO密集型
#define NOP_TIMES (10000000) //CPU密集型任务执行空指令次数
#define RAND_RANGE (1 << 18) //IO密集型任务休眠时间随机范围，单位：毫秒

void cpu_stress() {
    for (int i = 0; i < NOP_TIMES; i++) {
        ;
    }
}

void rand_sleep() {
    srand(time(0));
    int ms = rand() & (RAND_RANGE - 1);
    usleep(ms);
}

//任务处理函数
void task_cb(void *arg) { 
#if !TEST_TASK_TYPE
    cpu_stress();
#else
    rand_sleep();
#endif
    return;
}

atomic_int running_threads;
void *thread_proc1(void *arg) {
    atomic_fetch_add(&running_threads, 1);
    pthread_detach(pthread_self());
    task_t *task = (task_t *)arg;
    task->cb(task->arg);
    free(task);
    atomic_fetch_sub(&running_threads, 1);
    return NULL;
}

int main(int argc, char *argv[]) {

#if ENABLE_THREAD_POOL
    thread_pool_t *tp = thread_pool_create(CORE_THREAD_NUM, DYN_THREAD_MAX);
    if (!tp) {
        printf("thread_pool_create error");
        return -1;
    }

    int seq = 0;
    while(1) {
        usleep(TASK_INTERVAL);
        task_t *task = task_create(task_cb, NULL, FREE_TYPE);
        if (!task) {
            printf("task create error\n");
            usleep(10 * 1000);
            continue;
        }
        int ret = thread_add_task(tp, task);
        if (ret == -1) { //任务拒绝
            task_freep(&task);
            usleep(10 * 1000);
            continue;
        }
        if (seq++ >= TEST_TASK_NUM) {
            thread_pool_exit(tp);
            thread_pool_destroy_p(&tp);
            break;
        }
    }
    printf("thread pool test done------\n");

#else
    atomic_init(&running_threads, 0);
    int seq = 0;
    int old_num = 0;
    while(1) {
        usleep(TASK_INTERVAL);
        task_t *task = task_create(task_cb, NULL, FREE_TYPE);
        if (!task) {
            printf("task create error\n");
            usleep(10 * 1000);
            continue;
        }
        pthread_t th;
        int ret = pthread_create(&th, NULL, thread_proc1, (void *)task);
        if (ret != 0) {
            free(task);
            usleep(10 * 1000);
            continue;
        }

        int num = atomic_load(&running_threads);
        if (old_num < num) {
            old_num = num;
            printf("running_threads:%d\n", num);
        }
        if (seq++ >= TEST_TASK_NUM) break;
    }
    printf("threads test done------\n");
#endif

    return 0;
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.