int uv_run(uv_loop_t* loop, uv_run_mode mode) {
	//...
  int r;
  while (r != 0 && loop->stop_flag == 0) {
      //更新时间
    uv__update_time(loop);
      //timer阶段
    uv__run_timers(loop);
      //pending 阶段
    ran_pending = uv__run_pending(loop);
      //idle prepare阶段
    uv__run_idle(loop);
    uv__run_prepare(loop);
		//计算timeout
    timeout = 0;
    if ((mode == UV_RUN_ONCE && !ran_pending) || mode == UV_RUN_DEFAULT)
      timeout = uv_backend_timeout(loop);
	//poll阶段
    uv__io_poll(loop, timeout);
      //check阶段
    uv__run_check(loop);
      //close阶段
    uv__run_closing_handles(loop);
	//...
    r = uv__loop_alive(loop);
  }

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;
}

uint64_t uv__hrtime(uv_clocktype_t type) {
    //get high-resolution real time
  return gethrtime();
}

void uv__run_timers(uv_loop_t* loop) {
  struct heap_node* heap_node;
  uv_timer_t* handle;

  for (;;) {
      //获取timer的最小堆，堆顶
    heap_node = heap_min(timer_heap(loop));
    if (heap_node == NULL)
      break;
	//获取timer挂载的handle
    handle = container_of(heap_node, uv_timer_t, heap_node);
      //如果handle设定的timeout时间还没有到，则退出循环
    if (handle->timeout > loop->time)
      break;
	//停止计时器
    uv_timer_stop(handle);
      //重新启动计时器,处理循环计时器
    uv_timer_again(handle);
      //执行回调
    handle->timer_cb(handle);
  }
}

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;
}

int uv_backend_timeout(const uv_loop_t* loop) {
  if (loop->stop_flag != 0)
    return 0;

  if (!uv__has_active_handles(loop) && !uv__has_active_reqs(loop))
    return 0;

  if (!QUEUE_EMPTY(&loop->idle_handles))
    return 0;

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

  if (loop->closing_handles)
    return 0;

  return uv__next_timeout(loop);
}

int uv__next_timeout(const uv_loop_t* loop) {
  const struct heap_node* heap_node;
  const uv_timer_t* handle;
  uint64_t diff;
	//如果没有定时器，可以无限阻塞
  heap_node = heap_min(timer_heap(loop));
  if (heap_node == NULL)
    return -1; /* block indefinitely */
	//根据定时器下次时间确定最大等待时间
  handle = container_of(heap_node, uv_timer_t, heap_node);
  if (handle->timeout <= loop->time)
    return 0;

  diff = handle->timeout - loop->time;
  if (diff > INT_MAX)
    diff = INT_MAX;

  return (int) diff;
}

void uv__io_poll(uv_loop_t* loop, int timeout) {
//...
	//处理基础时间和最大循环次数
  base = loop->time;
  count = 48; /* Benchmarks suggest this gives the best throughput. */
  real_timeout = timeout;

  for (;;) {
	//...
      //获取监听的事件
      nfds = epoll_wait(loop->backend_fd,
                        events,
                        ARRAY_SIZE(events),
                        timeout);
	//..
    if (nfds == 0) {
      assert(timeout != -1);

      if (timeout == 0)
        return;
      goto update_timeout;
    }

   //...
	//处理监听的事件回调
    for (i = 0; i < nfds; i++) {
      pe = events + i;
      fd = pe->data.fd;
        //...
      w = loop->watchers[fd];
		//...
          w->cb(loop, w, pe->events);

        nevents++;
    }
	//...   
	
    if (nevents != 0) {
      if (nfds == ARRAY_SIZE(events) && --count != 0) {
        /* Poll for more events but don't block this time. */
          //进入下次轮询，但不要阻塞
        timeout = 0;
        continue;
      }
      return;
    }
	//耗时结束，直接返回
    if (timeout == 0)
      return;
	//若是允许阻塞轮询，则继续查询
    if (timeout == -1)
      continue;

      	//更新运行时间
update_timeout:
    assert(timeout > 0);

    real_timeout -= (loop->time - base);
    if (real_timeout <= 0)
      return;

    timeout = real_timeout;
  }
}