Nginx源码解析——线程池

  nginx是采用多进程模型，master和worker之间主要通过pipe管道的方式进行通信，多进程的优势就在于各个进程互不影响。其实，nginx代码中也提供了一个thread_pool（线程池）的核心模块来处理多任务的。主要放在ngx_thread_pool.c文件中。

线程池的数据结构

task结构，为单链表组成任务队列，主要成员是event事件和handler回调方法

id每次push进一个任务，pool的全局静态id会自增并分配 

//在中添加到了ngx_thread_pool_s->queue队列中，也就是添加到ngx_thread_pool_s对应的线程池队列中
struct ngx_thread_task_s {
    ngx_thread_task_t   *next; //指向下一个提交的任务  
    ngx_uint_t           id; //任务id  没添加一个任务就自增加，见ngx_thread_pool_task_id
    void                *ctx; //执行回调函数的参数  
    //ngx_thread_pool_cycle中执行
    void               (*handler)(void *data, ngx_log_t *log); //回调函数   执行完handler后会通过ngx_notify执行event->handler 
    //执行完handler后会通过ngx_notify执行event->handler 
    ngx_event_t          event; //一个任务和一个事件对应  事件在通过ngx_notify在ngx_thread_pool_handler中执行
};

threadpool结构。主要是任务队列，互斥锁，条件变量，线程个数，任务队列主要有头指针和尾指针的地址 

typedef struct {
    ngx_array_t               pools;
} ngx_thread_pool_conf_t;


typedef struct { //见ngx_thread_pool_done
    ngx_thread_task_t        *first;

    /*
     *ngx_thread_pool_t->queue.last = task;  新添加的任务通过last连接在一起
     ngx_thread_pool_t->queue.last = &task->next;  下次在添加新任务就让task->next指向新任务了
     */
    ngx_thread_task_t       **last;
} ngx_thread_pool_queue_t; //线程池队列  初始化在ngx_thread_pool_queue_init

#define ngx_thread_pool_queue_init(q)                                         \
    (q)->first = NULL;                                                        \
    (q)->last = &(q)->first


//一个该结构对应一个threads_pool配置
struct ngx_thread_pool_s {//该结构式存放在ngx_thread_pool_conf_t->pool数组中的，见ngx_thread_pool_init_worker
    ngx_thread_mutex_t        mtx; //线程锁  ngx_thread_pool_init中初始化
    //ngx_thread_task_post中添加的任务被添加到该队列中
    ngx_thread_pool_queue_t   queue;//ngx_thread_pool_init  ngx_thread_pool_queue_init中初始化
    //在该线程池poll中每添加一个线程，waiting子减，当线程全部正在执行任务后，waiting会恢复到0
    //如果所有线程都已经在执行任务(也就是waiting>-0)，又来了任务，那么任务就只能等待。所以waiting表示等待被执行的任务数
    ngx_int_t                 waiting;//等待的任务数   ngx_thread_task_post加1   ngx_thread_pool_cycle减1
    ngx_thread_cond_t         cond;//条件变量  ngx_thread_pool_init中初始化

    ngx_log_t                *log;//ngx_thread_pool_init中初始化

    ngx_str_t                 name;//thread_pool name threads=number [max_queue=number];中的name  ngx_thread_pool
    //如果没有配置，在ngx_thread_pool_init_conf默认赋值为32
    ngx_uint_t                threads;//thread_pool name threads=number [max_queue=number];中的number  ngx_thread_pool
    //如果没有配置，在ngx_thread_pool_init_conf默认赋值为65535  
    //指的是线程已经全部用完的情况下，还可以添加多少个任务到等待队列
    ngx_int_t                 max_queue;//thread_pool name threads=number [max_queue=number];中的max_queue  ngx_thread_pool

    u_char                   *file;//配置文件名
    ngx_uint_t                line;//thread_pool配置在配置文件中的行号
};

 

//创建线程池所需的基础结构
static ngx_int_t
ngx_thread_pool_init_worker(ngx_cycle_t *cycle)
{
    ngx_uint_t                i;
    ngx_thread_pool_t       **tpp;
    ngx_thread_pool_conf_t   *tcf;
    //如果不是worker或者只有一个worker就不起用线程池
    if (ngx_process != NGX_PROCESS_WORKER
        && ngx_process != NGX_PROCESS_SINGLE)
    {
        return NGX_OK;
    }
      
    //初始化任务队列
    ngx_thread_pool_queue_init(&ngx_thread_pool_done);
  
    tpp = tcf->pools.elts;
    for (i = 0; i < tcf->pools.nelts; i++) {
        //初始化各个线程池
        if (ngx_thread_pool_init(tpp[i], cycle->log, cycle->pool) != NGX_OK) {
            return NGX_ERROR;
        }
    }
  
    return NGX_OK;
}

 线程池的初始化：初始化互斥锁，条件变量，创建每个线程

static ngx_int_t
ngx_thread_pool_init(ngx_thread_pool_t *tp, ngx_log_t *log, ngx_pool_t *pool)
{
    int             err;
    pthread_t       tid;
    ngx_uint_t      n;
    pthread_attr_t  attr;

    if (ngx_notify == NULL) {
        ngx_log_error(NGX_LOG_ALERT, log, 0,
               "the configured event method cannot be used with thread pools");
        return NGX_ERROR;
    }

    ngx_thread_pool_queue_init(&tp->queue);

    if (ngx_thread_mutex_create(&tp->mtx, log) != NGX_OK) {
        return NGX_ERROR;
    }

    if (ngx_thread_cond_create(&tp->cond, log) != NGX_OK) {
        (void) ngx_thread_mutex_destroy(&tp->mtx, log);
        return NGX_ERROR;
    }

    tp->log = log;

    err = pthread_attr_init(&attr);
    if (err) {
        ngx_log_error(NGX_LOG_ALERT, log, err,
                      "pthread_attr_init() failed");
        return NGX_ERROR;
    }

    err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    if (err) {
        ngx_log_error(NGX_LOG_ALERT, log, err,
                      "pthread_attr_setdetachstate() failed");
        return NGX_ERROR;
    }

#if 0
    err = pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN);
    if (err) {
        ngx_log_error(NGX_LOG_ALERT, log, err,
                      "pthread_attr_setstacksize() failed");
        return NGX_ERROR;
    }
#endif

    for (n = 0; n < tp->threads; n++) {
        err = pthread_create(&tid, &attr, ngx_thread_pool_cycle, tp);
        if (err) {
            ngx_log_error(NGX_LOG_ALERT, log, err,
                          "pthread_create() failed");
            return NGX_ERROR;
        }
    }

    (void) pthread_attr_destroy(&attr);

    return NGX_OK;
}

每个线程创建后执行的函数，data参数传进来的就是线程池，主要执行一个循环，每次循环取出等待的任务队列上的任务，如果没有阻塞等待条件满足了唤醒，之后调用task的handler方法之后会用自旋锁保护done队列，ngx_thread_pool_done队列是调用过handler进入线程处理的队列，每次把task执行完handler后push进队列中，然后唤醒ngx_notify(ngx_thread_pool_handler)方法， 正式进入事件的处理，ngx_memory_barrier()是为了//防止编译器优化，保证解锁操作是在上述语句执行完毕后再去执行的。

static void *
ngx_thread_pool_cycle(void *data)
{
    ngx_thread_pool_t *tp = data;

    int                 err;
    sigset_t            set;
    ngx_thread_task_t  *task;

#if 0
    ngx_time_update();
#endif

    ngx_log_debug1(NGX_LOG_DEBUG_CORE, tp->log, 0,
                   "thread in pool \"%V\" started", &tp->name);

    sigfillset(&set);

    sigdelset(&set, SIGILL);
    sigdelset(&set, SIGFPE);
    sigdelset(&set, SIGSEGV);
    sigdelset(&set, SIGBUS);

    err = pthread_sigmask(SIG_BLOCK, &set, NULL);
    if (err) {
        ngx_log_error(NGX_LOG_ALERT, tp->log, err, "pthread_sigmask() failed");
        return NULL;
    }

    for ( ;; ) {
        if (ngx_thread_mutex_lock(&tp->mtx, tp->log) != NGX_OK) {
            return NULL;
        }

        /* the number may become negative */
        tp->waiting--;

        while (tp->queue.first == NULL) {
            if (ngx_thread_cond_wait(&tp->cond, &tp->mtx, tp->log)
                != NGX_OK)
            {
                //异常情况捕获释放锁后返回
                (void) ngx_thread_mutex_unlock(&tp->mtx, tp->log);
                return NULL;
            }
        }

        task = tp->queue.first;
        tp->queue.first = task->next;

        if (tp->queue.first == NULL) {
            tp->queue.last = &tp->queue.first;
        }

        if (ngx_thread_mutex_unlock(&tp->mtx, tp->log) != NGX_OK) {
            return NULL;
        }

#if 0
        ngx_time_update();
#endif

        ngx_log_debug2(NGX_LOG_DEBUG_CORE, tp->log, 0,
                       "run task #%ui in thread pool \"%V\"",
                       task->id, &tp->name);

        task->handler(task->ctx, tp->log);

        ngx_log_debug2(NGX_LOG_DEBUG_CORE, tp->log, 0,
                       "complete task #%ui in thread pool \"%V\"",
                       task->id, &tp->name);

        task->next = NULL;

        ngx_spinlock(&ngx_thread_pool_done_lock, 1, 2048);

        *ngx_thread_pool_done.last = task;
        ngx_thread_pool_done.last = &task->next;

        ngx_memory_barrier();

        ngx_unlock(&ngx_thread_pool_done_lock);
        //处理task任务
        (void) ngx_notify(ngx_thread_pool_handler);
    }
}

线程主要执行的方法，参数的ev并没有实际用途，先用自旋锁保护done队列，从done队列上取出预处理过的task，这里之所以设计done队列，应该是为了各个线程的负载，这里task取出后会调用event事件的回调然后继续执行下一个task

//任务处理完后，epoll的通知读事件会调用该函数 
ngx_notify通告主线程，该任务处理完毕，ngx_thread_pool_handler由主线程执行，也就是进程cycle{}通过epoll_wait返回执行，而不是由线程池中的线程执行
static void
ngx_thread_pool_handler(ngx_event_t *ev)
{
    ngx_event_t        *event;
    ngx_thread_task_t  *task;

    ngx_log_debug0(NGX_LOG_DEBUG_CORE, ev->log, 0, "thread pool handler");

    ngx_spinlock(&ngx_thread_pool_done_lock, 1, 2048);

    /* 这里是不是有问题?
        如果线程池中的线程执行任务比较快，而主进程在执行epoll_wait过程中有点阻塞，那么就检测不到ngx_notify中的epoll事件，有可能下次检测到该事件的时候
        ngx_thread_pool_done上已经积累了很多执行完的任务事件，见ngx_thread_pool_cycle。
        单这里好像只取了队列首部的任务啊?????? 队首外的任务丢弃了???????????不对吧

        答案是，这里面所有的任务都在下面的while{}中得到了执行
     */

    task = ngx_thread_pool_done.first;
    ngx_thread_pool_done.first = NULL;
    //尾部指向头，但是头已经变为空，即不执行任务  
    ngx_thread_pool_done.last = &ngx_thread_pool_done.first;

    ngx_unlock(&ngx_thread_pool_done_lock);

    while (task) {//遍历执行前面队列ngx_thread_pool_done中的每一个任务  
        ngx_log_debug1(NGX_LOG_DEBUG_CORE, ev->log, 0,
                       "run completion handler for task #%ui", task->id);

        event = &task->event;
        task = task->next;

        event->complete = 1;
        event->active = 0;

      /*如果是小文件，则一次可以读完，函数指向可以参考ngx_http_cache_thread_handler  ngx_http_copy_thread_handler  ngx_thread_read

        如果是大文件下载，则第一次走这里函数式上面的几个函数，但是由于一次最多获取32768字节，因此需要多次读取文件，就是由一次tread执行完任务后
        触发ngx_notify通道epoll，然后走到这里继续读 
        */
        event->handler(event);//这里是否应该检查event->handler是否为空，例如参考ngx_thread_pool_destroy
    }

将task放入pool的等待队列上，并唤醒 

ngx_int_t
ngx_thread_task_post(ngx_thread_pool_t *tp, ngx_thread_task_t *task)
{
    if (task->event.active) {
        ngx_log_error(NGX_LOG_ALERT, tp->log, 0,
                      "task #%ui already active", task->id);
        return NGX_ERROR;
    }

    if (ngx_thread_mutex_lock(&tp->mtx, tp->log) != NGX_OK) {
        return NGX_ERROR;
    }

    if (tp->waiting >= tp->max_queue) {
        (void) ngx_thread_mutex_unlock(&tp->mtx, tp->log);

        ngx_log_error(NGX_LOG_ERR, tp->log, 0,
                      "thread pool \"%V\" queue overflow: %i tasks waiting",
                      &tp->name, tp->waiting);
        return NGX_ERROR;
    }

    task->event.active = 1;

    task->id = ngx_thread_pool_task_id++;
    task->next = NULL;

    if (ngx_thread_cond_signal(&tp->cond, tp->log) != NGX_OK) {
        (void) ngx_thread_mutex_unlock(&tp->mtx, tp->log);
        return NGX_ERROR;
    }

    *tp->queue.last = task;
    tp->queue.last = &task->next;

    tp->waiting++;

    (void) ngx_thread_mutex_unlock(&tp->mtx, tp->log);

    ngx_log_debug2(NGX_LOG_DEBUG_CORE, tp->log, 0,
                   "task #%ui added to thread pool \"%V\"",
                   task->id, &tp->name);

    return NGX_OK;
}