Libuv源码分析 —— 6. 事件循环【uv_run】

最新推荐文章于 2024-05-15 20:00:57 发布

Anita-Sun

最新推荐文章于 2024-05-15 20:00:57 发布

阅读量1.8k

点赞数

分类专栏： Libuv源码解析文章标签： libuv

本文链接：https://blog.csdn.net/AnitaSun/article/details/124052582

版权

Libuv源码解析专栏收录该内容

12 篇文章 24 订阅

订阅专栏

通过之前的学习，咱们已经明白了在事件循环中的三个核心内容，分别是：

Libuv源码分析 —— 定时器

Libuv源码分析 —— idle、prepare、check

Libuv源码分析 —— poll io

现在让咱们从头捋一遍事件循环到底完成了什么功能呢？

uv_run

int uv_run(uv_loop_t* loop, uv_run_mode mode)
这个函数运行事件循环。它将依指定的模式而采取不同的行为：
- UV_RUN_DEFAULT：运行事件循环直到没有更多的活动的和被引用到的句柄或请求。返回非零如果 uv_stop() 被调用且仍有活动的句柄或请求。在所有其他情况下返回零。
- UV_RUN_ONCE：轮询I/O一次。注意如若没有待处理的回调函数这个函数阻塞。返回零当完成时（没有剩余的活动的句柄或请求），或者非零值如果期望更多回调函数时（意味着你应该在未来某时再次运行这个事件循环）。
- UV_RUN_NOWAIT：轮询I/O一次但不会阻塞，如若没有待处理的回调函数时。返回零当完成时（没有剩余的活动的句柄或请求），或者非零值如果期望更多回调函数时（意味着你应该在未来某时再次运行这个事件循环）。

uv_run 源码

int uv_run(uv_loop_t* loop, uv_run_mode mode) {
 int timeout;
 int r;
 int ran_pending;

 r = uv__loop_alive(loop);
 if (!r)
   uv__update_time(loop);

 while (r != 0 && loop->stop_flag == 0) {
   // 更新时间并开始倒计时 loop->time
   uv__update_time(loop);
   // 执行超时回调
   uv__run_timers(loop);
   // 执行 pending 回调，ran_pending 代表 pending 队列是否为空，即没有节点可以执行
   ran_pending = uv__run_pending(loop);
   // 运行idle handle
   uv__run_idle(loop);
   // 运行prepare handle
   uv__run_prepare(loop);

   timeout = 0;
   // UV_RUN_ONCE 并且有 pending 节点的时候，会阻塞式 poll io，默认模式也是
   if ((mode == UV_RUN_ONCE && !ran_pending) || mode == UV_RUN_DEFAULT)
     timeout = uv__backend_timeout(loop);

   // 计算要阻塞的时间，开始阻塞
   // poll io timeout 是 epoll_wait 的超时时间
   uv__io_poll(loop, timeout);

   uv__metrics_update_idle_time(loop);

   // 程序执行到这里表示被唤醒了，被唤醒的原因可能是I/O可读可写、或者超时了，检查handle是否可以操作
   uv__run_check(loop);
   // 看看是否有close的handle
   uv__run_closing_handles(loop);

   // 单次模式 
   // 还有一次执行超时回调的机会
   if (mode == UV_RUN_ONCE) {
     uv__update_time(loop);
     uv__run_timers(loop);
   }

   // handle保活处理
   r = uv__loop_alive(loop);
   if (mode == UV_RUN_ONCE || mode == UV_RUN_NOWAIT)
     break;
 }
 
 // 修改停止标记，退出循环
 if (loop->stop_flag != 0)
   loop->stop_flag = 0;

 return r;
}

源码分析

uv__loop_alive

判断事件循环是否可以继续执行下去

static int uv__loop_alive(const uv_loop_t* loop) {
  return uv__has_active_handles(loop) ||
         uv__has_active_reqs(loop) ||
         !QUEUE_EMPTY(&loop->pending_queue) ||
         loop->closing_handles != NULL;
}

#define uv__has_active_handles(loop) ((loop)->active_handles > 0)
#define uv__has_active_reqs(loop) ((loop)->active_reqs.count > 0)

uv__update_time

更新当前时间

UV_UNUSED(static void uv__update_time(uv_loop_t* loop)) {
  /* Use a fast time source if available.  We only need millisecond precision.
   */
  loop->time = uv__hrtime(UV_CLOCK_FAST) / 1000000;
}

uv__run_pending

执行 loop->pending_queue 队列中的回调函数

static int uv__run_pending(uv_loop_t* loop) {
  QUEUE* q;
  QUEUE pq;
  uv__io_t* w;

  if (QUEUE_EMPTY(&loop->pending_queue))
    return 0;

  QUEUE_MOVE(&loop->pending_queue, &pq);

  while (!QUEUE_EMPTY(&pq)) {
    q = QUEUE_HEAD(&pq);
    QUEUE_REMOVE(q);
    QUEUE_INIT(q);
    w = QUEUE_DATA(q, uv__io_t, pending_queue);
    w->cb(loop, w, POLLOUT);
  }

  return 1;
}

uv__run_closing_handles

close 是 libuv 每轮事件循环中最后的一个阶段。我们看看怎么使用。我们知道对于一个 handle，他的使用一般是 init，start，stop。但是如果我们在 stop 一个 handle 之后，还有些事情需要处理怎么办？这时候就可以使用 close 阶段。close 阶段可以用来关闭一个 handle，并且执行一个回调。比如用于释放动态申请的内存。close 阶段的任务由 uv_close 产生

例如在停止 poll 的时候会调用 uv_close

int uv_fs_poll_stop(uv_fs_poll_t* handle) {
  struct poll_ctx* ctx;

  if (!uv_is_active((uv_handle_t*)handle))
    return 0;

  ctx = handle->poll_ctx;
  assert(ctx != NULL);
  assert(ctx->parent_handle == handle);

  if (uv_is_active((uv_handle_t*)&ctx->timer_handle))
    // 当结束监听的时候，他需要释放掉这块内存，通过回调函数传递释放内存的函数
    uv_close((uv_handle_t*)&ctx->timer_handle, timer_close_cb);

  uv__handle_stop(handle);

  return 0;
}

// 释放上下文结构体的内存 
static void timer_close_cb(uv_handle_t* handle) { 
    uv__free(container_of(handle, struct poll_ctx, timer_handle)); 
}

uv_close

void uv_close(uv_handle_t* handle, uv_close_cb close_cb) {
  assert(!uv__is_closing(handle));

  // 正在关闭，但是还没执行回调等后置操作
  // 设置状态和回调
  handle->flags |= UV_HANDLE_CLOSING;
  handle->close_cb = close_cb;

  // 根据 handle 类型调对应的 close 函数，一般 就是 stop 这个 handle
  switch (handle->type) {
  case UV_NAMED_PIPE:
    uv__pipe_close((uv_pipe_t*)handle);
    break;

  case UV_TTY:
    uv__stream_close((uv_stream_t*)handle);
    break;

  case UV_TCP:
    uv__tcp_close((uv_tcp_t*)handle);
    break;

  case UV_UDP:
    uv__udp_close((uv_udp_t*)handle);
    break;

  case UV_PREPARE:
    uv__prepare_close((uv_prepare_t*)handle);
    break;

  case UV_CHECK:
    uv__check_close((uv_check_t*)handle);
    break;

  case UV_IDLE:
    uv__idle_close((uv_idle_t*)handle);
    break;

  case UV_ASYNC:
    uv__async_close((uv_async_t*)handle);
    break;

  case UV_TIMER:
    uv__timer_close((uv_timer_t*)handle);
    break;

  case UV_PROCESS:
    uv__process_close((uv_process_t*)handle);
    break;

  case UV_FS_EVENT:
    uv__fs_event_close((uv_fs_event_t*)handle);
    break;

  case UV_POLL:
    uv__poll_close((uv_poll_t*)handle);
    break;

  case UV_FS_POLL:
    uv__fs_poll_close((uv_fs_poll_t*)handle);
    /* Poll handles use file system requests, and one of them may still be
     * running. The poll code will call uv__make_close_pending() for us. */
    return;

  case UV_SIGNAL:
    uv__signal_close((uv_signal_t*) handle);
    break;

  default:
    assert(0);
  }
  
  // 执行 uv__make_close_pending 往 close 队列追加节点
  uv__make_close_pending(handle);
}

void uv__make_close_pending(uv_handle_t* handle) {
  assert(handle->flags & UV_HANDLE_CLOSING);
  assert(!(handle->flags & UV_HANDLE_CLOSED));
  handle->next_closing = handle->loop->closing_handles;
  handle->loop->closing_handles = handle;
}

在事件循环中需要执行的步骤

static void uv__run_closing_handles(uv_loop_t* loop) {
  uv_handle_t* p;
  uv_handle_t* q;

  p = loop->closing_handles;
  loop->closing_handles = NULL;

  // 关闭 closing_handles 中的所有句柄
  while (p) {
    q = p->next_closing;
    uv__finish_close(p);
    p = q;
  }
}


static void uv__finish_close(uv_handle_t* handle) {
  uv_signal_t* sh;

  // 句柄处于正在关闭状态，而不是已关闭状态
  assert(handle->flags & UV_HANDLE_CLOSING);
  assert(!(handle->flags & UV_HANDLE_CLOSED));
  // 修改句柄状态为已关闭
  handle->flags |= UV_HANDLE_CLOSED;

  switch (handle->type) {
    case UV_PREPARE:
    case UV_CHECK:
    case UV_IDLE:
    case UV_ASYNC:
    case UV_TIMER:
    case UV_PROCESS:
    case UV_FS_EVENT:
    case UV_FS_POLL:
    case UV_POLL:
      break;

    case UV_SIGNAL:
      sh = (uv_signal_t*) handle;
      if (sh->caught_signals > sh->dispatched_signals) {
        handle->flags ^= UV_HANDLE_CLOSED;
        uv__make_close_pending(handle);  /* Back into the queue. */
        return;
      }
      break;

    case UV_NAMED_PIPE:
    case UV_TCP:
    case UV_TTY:
      uv__stream_destroy((uv_stream_t*)handle);
      break;

    case UV_UDP:
      uv__udp_finish_close((uv_udp_t*)handle);
      break;

    default:
      assert(0);
      break;
  }

  // 句柄的引用计数减一
  uv__handle_unref(handle);
  // 从 Handle 中移除
  QUEUE_REMOVE(&handle->handle_queue);

  // 如果设置了关闭的回调函数，执行这个回调函数
  if (handle->close_cb) {
    handle->close_cb(handle);
  }
}

uv__loop_alive

检查时间循环在执行这么多任务之后的状态，是否可以继续执行下一轮循环

static int uv__loop_alive(const uv_loop_t* loop) {
  return uv__has_active_handles(loop) ||
         uv__has_active_reqs(loop) ||
         !QUEUE_EMPTY(&loop->pending_queue) ||
         loop->closing_handles != NULL;
}

Anita-Sun

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Libuv源码分析 —— 6. 事件循环【uv_run】

通过之前的学习，咱们已经明白了在事件循环中的三个核心内容，分别是：Libuv源码分析 —— 定时器Libuv源码分析 —— idle、prepare、checkLibuv源码分析 —— poll io现在让咱们从头捋一遍事件循环到底完成了什么功能呢？uv_runint uv_run(uv_loop_t* loop, uv_run_mode mode)这个函数运行事件循环。它将依指定的模式而采取不同的行为：UV_RUN_DEFAULT：运行事件循环直到没有更.
复制链接

扫一扫

专栏目录