Nginx线程池浅析

小鱼儿 2023-01-11 01:13 197阅读 0赞

## nginx相关视频解析： ##

[nginx源码分析之内存池与线程池][nginx]  
[nginx源码在面试中出现的经典问题][nginx 1]  
[浅析nginx模块用在哪里？手把手带你实现nginx模块开发][nginx_nginx]

Nginx通过使用多路复用IO（如Linux的epoll、FreeBSD的kqueue等）技术很好的解决了c10k问题，但前提是Nginx的请求不能有阻塞操作，否则将会导致整个Nginx进程停止服务。

但很多时候阻塞操作是不可避免的，例如客户端请求静态文件时，由于磁盘IO可能会导致进程阻塞，所以将会导致Nginx的性能下降。为了解决这个问题，Nginx在1.7.11版本中实现了线程池机制。

下面我们将会分析Nginx是怎么通过线程池来解决阻塞操作问题。

## 启用线程池功能 ##

要使用线程池功能，首先需要在配置文件中添加如下配置项：

location / { 
        root /html;
      thread_pool default threads=32 max_queue=65536;
        aio threads=default;
    }

上面定义了一个名为“default”，包含32个线程，任务队列最多支持65536个请求的线程池。如果任务队列过载，Nginx将输出如下错误日志并拒绝请求：

thread pool “default” queue overflow: N tasks waiting

如果出现上面的错误，说明线程池的负载很高，这是可以通过添加线程数来解决这个问题。当达到机器的最高处理能力之后，增加线程数并不能改善这个问题。

## 一切从“源”开始 ##

下面主要通过剖析Nginx的源码来了解线程池机制实现原理。现在先来了解Nginx线程池的两个重要数据结构ngx\_thread\_pool\_t和ngx\_thread\_task\_t。

ngx_thread_pool_t结构体
    struct ngx_thread_pool_s { 
        ngx_thread_mutex_t        mtx;
        ngx_thread_pool_queue_t   queue;
        ngx_int_t                 waiting;
        ngx_thread_cond_t         cond;
        ngx_log_t                *log;
        ngx_str_t                 name;
        ngx_uint_t                threads;
        ngx_int_t                 max_queue;
        u_char                   *file;
        ngx_uint_t                line;
    };

下面解释下每个字段的用途：

1.  mtx: 互斥锁，用于锁定任务队列，避免竞争状态。
2.  queue: 任务队列。
3.  waiting: 有多少个任务正在等待处理。
4.  cond: 用于通知线程池有任务需要处理。
5.  name: 线程池名称。
6.  threads: 线程池由多少个线程组成（线程数）。
7.  max\_queue: 线程池最大能处理的任务数。

## ngx\_thread\_task\_t结构体 ##

struct ngx_thread_task_s { 
        ngx_thread_task_t   *next;
        ngx_uint_t           id;
     void                *ctx;
     void               (*handler)(void *data, ngx_log_t *log);
        ngx_event_t          event;
    };

下面解释下每个字段的用途：

1.  next: 指向下一个任务。
2.  id: 任务ID。
3.  ctx: 任务的上下文。
4.  handler: 处理任务的函数句柄。
5.  event: 跟任务关联的事件对象（当线程池处理成任务之后将会由主线程调用event对象的handler回调函数）。

**【文章福利】需要C/C++ Linux服务器架构师学习资料加群812855908（资料包括C/C++，Linux，golang技术，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK，ffmpeg等）**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center]

## 线程池初始化 ##

下面介绍下线程池的初始化过程。

在Nginx启动的时候，首先会调用ngx\_thread\_pool\_init\_worker()函数来初始化线程池。ngx\_thread\_pool\_init\_worker()函数最终会调用ngx\_thread\_pool\_init()，源码如下：

static ngx_int_t
    ngx_thread_pool_init(ngx_thread_pool_t *tp, ngx_log_t *log, ngx_pool_t *pool)
    { 
        ...
     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;
            }
    }
    ...
     return NGX_OK;
    }
    ngx_thread_pool_init()最终调用pthread_create()函数创建线程池中的工作线程，工作线程会从ngx_thread_pool_cycle()函数开始执行。
    ngx_thread_pool_cycle()函数源码如下：
    static void *
    ngx_thread_pool_cycle(void *data)
    { 
        ...
     for ( ;; ) { 
     if (ngx_thread_mutex_lock(&tp->mtx, tp->log) != NGX_OK) { 
     return NULL;
            }
            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;
            }
       // 处理任务
            task->handler(task->ctx, tp->log);
            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_unlock(&ngx_thread_pool_done_lock);
            (void) ngx_notify(ngx_thread_pool_handler); // 通知主线程
        }
    }

ngx\_thread\_pool\_cycle()函数的主要工作是从待处理的任务队列中获取一个任务，然后调用任务对象的handler()函数处理任务，完成后把任务放置到完成队列中，并通过ngx\_notify()通知主线程。

## 添加任务到任务队列 ##

通过上面的分析，我们知道了线程池是怎么从任务队列获取任务并处理。但任务队列的任务从哪里来的呢？因为Nginx的使命是处理客户端请求，所以可以知道任务是通过客户端请求产生的。也就是说，任务是主线程创建的（主线程负责处理客户端请求）。

主线程通过ngx\_thread\_task\_post()函数向任务队列中添加一个任务，代码如下：

ngx_int_t
    ngx_thread_task_post(ngx_thread_pool_t *tp, ngx_thread_task_t *task)
    { 
    ...
    if (ngx_thread_mutex_lock(&tp->mtx, tp->log) != NGX_OK) { 
     return NGX_ERROR;
    }
     // 通知线程池有任务需要处理
     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);
     return NGX_OK;
    }

ngx\_thread\_task\_post()函数首先调用ngx\_thread\_cond\_signal()通知线程池的线程有任务需要处理，然后把任务添加到任务队列中。可能有人会问，先通知线程池在添加任务到任务队列中会不会有顺序问题。其实这样做是没问题的，这是因为只要主线程不调用ngx\_thread\_mutex\_unlock()把互斥锁解开，线程池中的工作线程是不会从ngx\_thread\_cond\_wait()返回的。

## 收尾工作 ##

当线程池把任务处理完后会把其放置到完成队列中（ngx\_thread\_pool\_done），然后调用ngx\_notify()通知主线程有任务完成了。主线程收到通知后，会在事件模块中进行收尾工作：调用task.event.handler()。task.event.handler由任务创建者设置，例如在ngx\_http\_copy\_filter模块的ngx\_http\_copy\_thread\_handler()函数：

static ngx_int_t
    ngx_http_copy_thread_handler(ngx_thread_task_t *task, ngx_file_t *file)
    { 
        ...
     if (tp == NULL) { 
     if (ngx_http_complex_value(r, clcf->thread_pool_value, &name)
                != NGX_OK)
            { 
     return NGX_ERROR;
            }
            tp = ngx_thread_pool_get((ngx_cycle_t *) ngx_cycle, &name);
        }
    task->event.data = r;
    // 设置event的回调函数
        task->event.handler = ngx_http_copy_thread_event_handler;
     if (ngx_thread_task_post(tp, task) != NGX_OK) { 
     return NGX_ERROR;
        }
        r->main->blocked++;
        r->aio = 1;
     return NGX_OK;
    }

task.event.handler被设置为ngx\_http\_copy\_thread\_event\_handler，就是说当任务处理完成后，主线程将会调用ngx\_http\_copy\_thread\_event\_handler来进行收尾工作。

## 哪些操作会使用线程池 ##

那么哪些操作会使用线程池去处理。一般来说，磁盘IO会使用线程池来处理。在ngx\_http\_copy\_filter模块中，会调用ngx\_thread\_read()读取文件的内容（当启用了线程池时），而ngx\_thread\_read()会把读取文件内容的操作让线程池去处理。ngx\_thread\_read()代码如下：

ssize_t
    ngx_thread_read(ngx_thread_task_t **taskp, ngx_file_t *file, u_char *buf,
        size_t size, off_t offset, ngx_pool_t *pool)
    { 
        ...
        task = *taskp;
     if (task == NULL) { 
            task = ngx_thread_task_alloc(pool, sizeof(ngx_thread_read_ctx_t));
     if (task == NULL) { 
     return NGX_ERROR;
            }
            task->handler = ngx_thread_read_handler;
            *taskp = task;
        }
        ctx = task->ctx;
        ...
        ctx->fd = file->fd;
        ctx->buf = buf;
        ctx->size = size;
        ctx->offset = offset;
     if (file->thread_handler(task, file) != NGX_OK) { 
     return NGX_ERROR;
        }
     return NGX_AGAIN;
    }

从上面的代码看到，task的handler被设置为ngx\_thread\_read\_handler，也就是说在线程池中将会调用ngx\_thread\_read\_handler()去读取文件内容。而file->thread\_handler()将会调用ngx\_thread\_task\_post()，前面已经分析过，ngx\_thread\_task\_post()会把任务添加到任务队列中。

## 图解 ##

最后用一张图来解释Nginx线程池机制的原理吧。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 1]

[nginx]: https://www.bilibili.com/video/BV1Xh411y7w9/
[nginx 1]: https://www.bilibili.com/video/BV1kK4y1Z7SE/
[nginx_nginx]: https://www.bilibili.com/video/BV1Rh411o7C2/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20210125155958236.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/2021012515564751.jpeg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwOTg5NzY5,size_16,color_FFFFFF,t_70#pic_center