线程池与性能

1、为什么要使用线程池？

        某类任务非常耗时，严重影响该线程执行其他任务；任务主要分两类，一类是磁盘io，一类是网络io，在处理这些io任务的时候非常耗时，会长期占用cpu可能会影响其他任务的处理；

2、使用线程池原理

        在其他线程中异步处理耗时任务，当有耗时任务需要处理的时候，创建一个线程去异步执行这些耗时任务，但是开启线程数量和cpu核数有关，所以开启处理耗时任务的线程数量是有限的；需要在cpu核心之间做出平衡选择；从而通过创建和销毁线程来固定线程数量；但是创建和销毁线程非常消耗线程资源，所以将创建的线程放入线程池中来复用线程资源；充分利用系统资源来异步执行耗时任务；

3、线程池具体实现

        线程池是生产者消费者模式：生产者线程发布耗时任务，队列存放任务（有任务的上下文和任务的执行函数），任务的上下文本来实在生产者中执行的，现在要放在消费者线程中执行，线程池是一定线程数量的集合，消费者线程取出并执行任务，通过线程调度唤起休眠线程，唤起线程需要加锁mutex和条件变量condition；线程状态有从无到有及从有到无两种状态，通过条件变量唤醒线程或休眠线程，条件即使队列的状态，如果队列中有任务则唤醒线程，如果没有任务，则让线程睡眠，生产者发布任务后通知休眠线程唤醒来开展取出并执行任务的工作；

        线程需要平衡选择，平衡选择根据具体的耗时任务进行，耗时任务分为两种，io密集和cpu密集；io密集型会阻塞线程，cpu密集型则cpu长期被一个线程占用，不能处理其他任务；线程池中线程的个数如果是cpu密集型则和cpu核数相等，如果是io密集型则线程个数通常是2*cpu核数+2；

        如何确定线程池线程数量：

                                （io等待时间+cpu运算时间）*核数/cpu运算时间

4、实现线程池

 接口设计：1）产生线程池接口，参数包括线程池数量，队列长度（因为线程的栈空间是固定的）

                    2）销毁线程池接口，参数包括标记线程池推出，通知所有线程

                    3）生产者抛出任务的接口，构造任务，放入队列，通知线程唤醒

                    4）线程池使用对象主要是生产者线程，是生产者线程使用线程池；

代码实现：

#ifndef _THREAD_POOL_H

#define _THREAD_POOL_H

typedef struct thread_pool_t thread_pool_t;

typedef void (*handler_pt) (void *);

thread_pool_t *thread_pool_create(int thrd_count, int queue_size);

int thread_pool_post(thread_pool_t *pool, handler_pt func, void *arg);

int thread_pool_destroy(thread_pool_t *pool);

int wait_all_done(thread_pool_t *pool);

#endif

#include <pthread.h>

#include <stdint.h>

#include <stddef.h>

#include <stdlib.h>

#include "thrd_pool.h"

typedef struct task_t {

    handler_pt func;

    void * arg;

} task_t;

typedef struct task_queue_t {

    uint32_t head;

    uint32_t tail;

    uint32_t count;

    task_t *queue;

} task_queue_t;

struct thread_pool_t {

    pthread_mutex_t mutex;

    pthread_cond_t condition;

    pthread_t *threads;

    task_queue_t task_queue;

    int closed;

    int started; // 当前运行的线程数

    int thrd_count;

    int queue_size;

};

static void * thread_worker(void *thrd_pool);

static void thread_pool_free(thread_pool_t *pool);

thread_pool_t *

thread_pool_create(int thrd_count, int queue_size) {

    thread_pool_t *pool;

    if (thrd_count <= 0 || queue_size <= 0) {

        return NULL;

    }

    pool = (thread_pool_t*) malloc(sizeof(*pool));

    if (pool == NULL) {

        return NULL;

    }

    pool->thrd_count = 0;

    pool->queue_size = queue_size;

    pool->task_queue.head = 0;

    pool->task_queue.tail = 0;

    pool->task_queue.count = 0;

    pool->started = pool->closed = 0;

    pool->task_queue.queue = (task_t*)malloc(sizeof(task_t)*queue_size);

    if (pool->task_queue.queue == NULL) {

        // TODO: free pool

        return NULL;

    }

    pool->threads = (pthread_t*) malloc(sizeof(pthread_t) * thrd_count);

    if (pool->threads == NULL) {

        // TODO: free pool

        return NULL;

    }

    int i = 0;

    for (; i < thrd_count; i++) {

        if (pthread_create(&(pool->threads[i]), NULL, thread_worker, (void*)pool) != 0) {

            // TODO: free pool

            return NULL;

        }

        pool->thrd_count++;

        pool->started++;

    }

    return pool;

}

int

thread_pool_post(thread_pool_t *pool, handler_pt func, void *arg) {

    if (pool == NULL || func == NULL) {

        return -1;

    }

    task_queue_t *task_queue = &(pool->task_queue);

    if (pthread_mutex_lock(&(pool->mutex)) != 0) {

        return -2;

    }

    if (pool->closed) {

        pthread_mutex_unlock(&(pool->mutex));

        return -3;

    }

    if (task_queue->count == pool->queue_size) {

        pthread_mutex_unlock(&(pool->mutex));

        return -4;

    }

    task_queue->queue[task_queue->tail].func = func;

    task_queue->queue[task_queue->tail].arg = arg;

    task_queue->tail = (task_queue->tail + 1) % pool->queue_size;

    task_queue->count++;

    if (pthread_cond_signal(&(pool->condition)) != 0) {

        pthread_mutex_unlock(&(pool->mutex));

        return -5;

    }

    pthread_mutex_unlock(&(pool->mutex));

    return 0;

}

static void

thread_pool_free(thread_pool_t *pool) {

    if (pool == NULL || pool->started > 0) {

        return;

    }

    if (pool->threads) {

        free(pool->threads);

        pool->threads = NULL;

        pthread_mutex_lock(&(pool->mutex));

        pthread_mutex_destroy(&pool->mutex);

        pthread_cond_destroy(&pool->condition);

    }

    if (pool->task_queue.queue) {

        free(pool->task_queue.queue);

        pool->task_queue.queue = NULL;

    }

    free(pool);

}

int

wait_all_done(thread_pool_t *pool) {

    int i, ret=0;

    for (i=0; i < pool->thrd_count; i++) {

        if (pthread_join(pool->threads[i], NULL) != 0) {

            ret=1;

        }

    }

    return ret;

}

int

thread_pool_destroy(thread_pool_t *pool) {

    if (pool == NULL) {

        return -1;

    }

    if (pthread_mutex_lock(&(pool->mutex)) != 0) {

        return -2;

    }

    if (pool->closed) {

        thread_pool_free(pool);

        return -3;

    }

    pool->closed = 1;

    if (pthread_cond_broadcast(&(pool->condition)) != 0 ||

            pthread_mutex_unlock(&(pool->mutex)) != 0) {

        thread_pool_free(pool);

        return -4;

    }

    wait_all_done(pool);

    thread_pool_free(pool);

    return 0;

}

static void *

thread_worker(void *thrd_pool) {

    thread_pool_t *pool = (thread_pool_t*)thrd_pool;

    task_queue_t *que;

    task_t task;

    for (;;) {

        pthread_mutex_lock(&(pool->mutex));

        que = &pool->task_queue;

        // 虚假唤醒   linux  pthread_cond_signal

        // linux 可能被信号唤醒

        // 业务逻辑不严谨，被其他线程抢了该任务

        while (que->count == 0 && pool->closed == 0) {

            // pthread_mutex_unlock(&(pool->mutex))

            // 阻塞在 condition

            // ===================================

            // 解除阻塞

            // pthread_mutex_lock(&(pool->mutex));

            pthread_cond_wait(&(pool->condition), &(pool->mutex));

        }

        if (pool->closed == 1) break;

        task = que->queue[que->head];

        que->head = (que->head + 1) % pool->queue_size;

        que->count--;

        pthread_mutex_unlock(&(pool->mutex));

        (*(task.func))(task.arg);

    }

    pool->started--;

    pthread_mutex_unlock(&(pool->mutex));

    pthread_exit(NULL);

    return NULL;

}

                

5、reactor模型中使用线程池

 可以用于处理decode，read，compute，encode，send任务，以为这些任务非常耗时；

6、nginx中的线程池

   

read读取出数据后，通过decode解码，由于compute的任务非常耗时，线程池可以用于执行compute任务；