Mongoose源码笔记——master_thread_ctx->sqhead-优快云博客

本文链接：https://blog.youkuaiyun.com/liangyuannao/article/details/8556686

参考：http://blog.youkuaiyun.com/larryliuqing/article/details/7544374 和http://www.cnblogs.com/skynet/archive/2010/07/24/1784476.html

Mongoose通过调用mg_start()启动一个master_thread线程，用于监听所有的client连接请求。

启动一个主线程即启动了一个web server，在主线程中首先会将该server监听的地址（socket）加入到监听集合中去。然后一直监听该端口，只要有client的连接请求到来，它会调用accept_new_connection()去处理连接请求。

接下来，我们关注的是accept_new_connection()是如何去处理连接请求的。首先它会进行一些预判工作，决定是否允许该连接。如果允许，则调用produce_socket并将处理工作转交给它，所谓权力下放。

在produce_socket()首先也会进行一些预判工作——判断mg_context结构体的成员变量queue队列是否已满，如果满了就等待直到queue有位置容纳请求。还有一点要说明的是：由于有可能多个client请求同时到达，对queue进行操作，所以在produce_socket()中一开始就设置(void) pthread_mutex_lock(&ctx->thr_mutex)；而且请求是通过调节变量来控制等待queue是否有位置容纳请求(void) pthread_cond_wait(&ctx->full_cond, &ctx->thr_mutex)。说了这么多准备工作，现在该正式进入工作了。至此，如果没有空闲进程且进程数量没有达到最大阈值，就会启动一个新的工作进程worker_thread去处理client的请求。

master_thread中维护着一个fd_set集合，这个集合用于存储所有来自客户端请求的socket。先后使用了FD_ZERO、FD_SET、select、FD_ISSET等用于同步多路I/O复用的函数。

首先，FD_ZERO将fd_set这个文件描述符集(socket描述符也是文件描述符)清空，在对此集合进行设置前，必须对它进行初始化，如果不清空，原有的内存内容并不进行清理。

然后，将所有的监听的socket加入fd_set中，即调用add_to_set。在这个函数中，调用FD_SET方法，在fd_set中增加一个新的文件描述符，被增加的描述符由mg_context的num_listeners决定。

调用select方法判断tv.tv_sec = 1 即一秒时间内，被监听的描述符是否有事件发生，如果有则返回一个非0，否则返回0。这里的select方法，有必要讲讲，比如，fd_set长度为1字节，fd_set中的每一bit可以对应一个文件描述符fd。则1字节长的fd_set最大可以对应8个fd。

（1）执行fd_set set; FD_ZERO(&set); 则set用位表示是0000,0000。
（2）若fd＝5，执行FD_SET(fd,&set);后set变为0001,0000(第5位置为1)

（3）若再加入fd＝2，fd=1,则set变为0001,0011
（4）执行select(6,&set,0,0,0)阻塞等待
（5）若fd=1,fd=2上都发生可读事件，则select返回，此时set变为0000,0011。注意：没有事件发生的fd=5被清空。

随后，判断select的返回值，如果小于0，说明出错，否则，用判断FD_ISSET是否文件描述符是否在该集合中，如果在，用accept_new_connection处理请求。

源码如下：

static void *master_thread(void *thread_func_param) {
  struct mg_context *ctx = thread_func_param;
  struct pollfd *pfd;
  int i;

  // Increase priority of the master thread


#if defined(ISSUE_317)
  struct sched_param sched_param;
  sched_param.sched_priority = sched_get_priority_max(SCHED_RR);
  pthread_setschedparam(pthread_self(), SCHED_RR, &sched_param);
#endif

  pfd = calloc(ctx->num_listening_sockets, sizeof(pfd[0]));
  printf("ctx->num_listening_sockets:%d\n",ctx->num_listening_sockets  while (ctx->stop_flag == 0) {
    for (i = 0; i < ctx->num_listening_sockets; i++) {
      pfd[i].fd = ctx->listening_sockets[i].sock;
      pfd[i].events = POLLIN;
    }

    if (poll(pfd, ctx->num_listening_sockets, 200) > 0) {
      for (i = 0; i < ctx->num_listening_sockets; i++) {
        if (ctx->stop_flag == 0 && pfd[i].revents == POLLIN) {
          accept_new_connection(&ctx->listening_sockets[i], ctx);
        }
      }
    }
  }
  free(pfd);
  DEBUG_TRACE(("stopping workers"));

  // Stop signal received: somebody called mg_stop. Quit.
  close_all_listening_sockets(ctx);

  // Wakeup workers that are waiting for connections to handle.
  pthread_cond_broadcast(&ctx->sq_full);

  // Wait until all threads finish
  (void) pthread_mutex_lock(&ctx->mutex);
  while (ctx->num_threads > 0) {
    (void) pthread_cond_wait(&ctx->cond, &ctx->mutex);
  }
  (void) pthread_mutex_unlock(&ctx->mutex);

  // All threads exited, no sync is needed. Destroy mutex and condvars
  (void) pthread_mutex_destroy(&ctx->mutex);
  (void) pthread_cond_destroy(&ctx->cond);
  (void) pthread_cond_destroy(&ctx->sq_empty);
  (void) pthread_cond_destroy(&ctx->sq_full);

#if !defined(NO_SSL)
  uninitialize_ssl(ctx);
#endif
  DEBUG_TRACE(("exiting"));

  // Signal mg_stop() that we're done.
  // WARNING: This must be the very last thing this
  // thread does, as ctx becomes invalid after this line.
  ctx->stop_flag = 2;
  return NULL;
}

accept_new_connection函数:首先它会进行一些预判工作，决定是否允许该连接。如果允许，则调用produce_socket并将处理工作转交给它，所谓权力下放。

static void accept_new_connection(const struct socket *listener,
                                  struct mg_context *ctx) {
  struct socket accepted;
  char src_addr[20];
  socklen_t len;
  int allowed;

  len = sizeof(accepted.rsa);
  accepted.lsa = listener->lsa;
  accepted.sock = accept(listener->sock, &accepted.rsa.sa, &len);
  if (accepted.sock != INVALID_SOCKET) {
    allowed = check_acl(ctx, ntohl(* (uint32_t *) &accepted.rsa.sin.sin_addr));
    if (allowed) {
      // Put accepted socket structure into the queue
      DEBUG_TRACE(("accepted socket %d", accepted.sock));
      accepted.is_ssl = listener->is_ssl;
      produce_socket(ctx, &accepted);
    } else {
      sockaddr_to_string(src_addr, sizeof(src_addr), &accepted.rsa);
      cry(fc(ctx), "%s: %s is not allowed to connect", __func__, src_addr);
      (void) closesocket(accepted.sock);
    }
  }
}

produce_socket函数：将接收的socket放在队列中，在produce_socket()首先也会进行一些预判工作——判断mg_context结构体的成员变量queue队列是否已满，如果满了就等待直到queue有位置容纳请求。还有一点要说明的是：由于有可能多个client请求同时到达，对queue进行操作，所以在produce_socket()()中一开始就设置(void) pthread_mutex_lock(&ctx->thr_mutex)；而且请求是通过调节变量来控制等待queue是否有位置容纳请求(void) pthread_cond_wait(&ctx->full_cond, &ctx->thr_mutex)。说了这么多准备工作，现在该正式进入工作了。至此，如果没有空闲进程且进程数量没有达到最大阈值，就会启动一个新的工作进程worker_thread去处理client的请求。

// Master thread adds accepted socket to a queue
static void produce_socket(struct mg_context *ctx, const struct socket *sp) {
  (void) pthread_mutex_lock(&ctx->mutex);

  // If the queue is full, wait
  while (ctx->stop_flag == 0 &&
         ctx->sq_head - ctx->sq_tail >= (int) ARRAY_SIZE(ctx->queue)) {
    (void) pthread_cond_wait(&ctx->sq_empty, &ctx->mutex);
  }

  if (ctx->sq_head - ctx->sq_tail < (int) ARRAY_SIZE(ctx->queue)) {
    // Copy socket to the queue and increment head
    ctx->queue[ctx->sq_head % ARRAY_SIZE(ctx->queue)] = *sp;
    ctx->sq_head++;
    DEBUG_TRACE(("queued socket %d", sp->sock));
  }

  (void) pthread_cond_signal(&ctx->sq_full);
  (void) pthread_mutex_unlock(&ctx->mutex);
}