【Node.js】时序API深度解析：从setTimeout到process.nextTick的执行逻辑

1
function insert(timer, msecs, start) {
2
  // 转为整数，避免浮点数精度问题（如1.1*100=110.00000000000001）
3
  msecs = Math.trunc(msecs)
4
  // 尝试从Map中获取对应超时时间的链表，不存在则新建
5
  let list = timerListMap.get(msecs)
6
  if (!list) {
7
    list = new TimersList(start + msecs, msecs) // 新链表的expiry是最近过期时间
8
    timerListMap.set(msecs, list)
9
    timerListQueue.insert(list) // 插入优先队列
10
    // 如果当前链表的expiry比全局下一个过期时间更早，更新全局定时器
11
    if (list.expiry < nextExpiry) {
12
      scheduleTimer(list.expiry)
13
      nextExpiry = list.expiry
14
    }
15
  }
16
  list.append(timer) // 将Timeout实例插入链表尾部
17
}

1
function processTimers(now) {
2
  let list
3
  // 循环取出优先队列中最快过期的链表
4
  while ((list = timerListQueue.peek()) !== null) {
5
    if (list.expiry > now) break // 未到执行时间，退出循环
6
    listOnTimeout(list, now) // 处理当前链表的过期任务
7
  }
8
}
9

10
function listOnTimeout(list, now) {
11
  let timer
12
  // 遍历链表，执行所有已过期的Timeout
13
  while ((timer = list.peek()) !== null) {
14
    const diff = now - timer._idleStart
15
    if (diff < list.msecs) break // 未过期，退出循环
16
    list.remove(timer) // 从链表中移除已处理的任务
17
    timer._onTimeout() // 执行用户回调
18
    // 如果是setInterval，重新插入队列（重复执行）
19
    if (timer._repeat) {
20
      timer._idleStart = now // 更新任务的起始时间
21
      insert(timer, timer._repeat, now) // 重新插入队列
22
    }
23
  }
24
}

1
const orders = new Map() // 存储订单，key为订单ID，value为订单信息
2

3
/**
4
 * 创建订单
5
 * @param {string} orderId 订单ID
6
 */
7
function createOrder(orderId) {
8
  orders.set(orderId, {
9
    status: 'unpaid', // 初始状态：未支付
10
    createTime: Date.now(), // 订单创建时间
11
  })
12
  // 30分钟后关闭订单（30*60*1000=1800000ms）
13
  setTimeout(() => closeOrder(orderId), 1800000)
14
}
15

16
/**
17
 * 关闭未支付订单
18
 * @param {string} orderId 订单ID
19
 */
20
function closeOrder(orderId) {
21
  const order = orders.get(orderId)
22
  if (order && order.status === 'unpaid') {
23
    order.status = 'closed'
24
    console.log(`订单${orderId}已关闭（30分钟未支付）`)
25
    orders.delete(orderId) // 从内存中移除
26
  }
27
}
28

29
// 测试：创建订单
30
createOrder('order_123')

1
// 1.5分钟 = 90000ms，但1.5*60*1000=90000.0000000001（浮点数精度问题）
2
const timeout = 1.5 * 60 * 1000
3
function exec(i) {
4
  console.log(i)
5
  setTimeout(exec, timeout, ++i)
6
}
7
exec(0)

1
list.expiry = Math.max(timer._idleStart + msecs, now + 1)

1
const immediateQueue = new ImmediateList() // 主队列
2
const outstandingQueue = new ImmediateList() // 防重入队列
3

4
function processImmediate() {
5
  // 选择队列：若outstandingQueue非空，优先处理（防重入）
6
  const queue = outstandingQueue.head ? outstandingQueue : immediateQueue
7
  if (queue === immediateQueue) {
8
    queue.head = queue.tail = null // 清空主队列，避免重入
9
  }
10
  let immediate
11
  // 遍历队列，执行所有Immediate
12
  while ((immediate = queue.peek()) !== null) {
13
    queue.remove(immediate)
14
    immediate._onImmediate() // 执行用户回调
15
  }
16
}

1
const Koa = require('koa')
2
const fs = require('fs/promises')
3
const sharp = require('sharp') // 图片处理库
4
const koaBody = require('koa-body') // 解析文件上传
5

6
const app = new Koa()
7
app.use(koaBody({ multipart: true })) // 启用文件上传
8

9
app.use(async (ctx) => {
10
  if (ctx.path === '/upload/avatar' && ctx.method === 'POST') {
11
    const file = ctx.request.files.avatar // 获取上传的文件
12
    const filePath = file.path // 临时文件路径
13
    const fileName = file.name // 文件名
14

15
    try {
16
      // 1. 保存原图到上传目录
17
      await fs.rename(filePath, `./uploads/avatars/${fileName}`)
18
      console.log(`原图保存成功：${fileName}`)
19

20
      // 2. 用setImmediate生成缩略图（Poll阶段后执行）
21
      setImmediate(async () => {
22
        await sharp(`./uploads/avatars/${fileName}`)
23
          .resize(100, 100) // 缩放到100x100
24
          .toFile(`./uploads/avatars/thumb_${fileName}`)
25
        console.log(`缩略图生成成功：thumb_${fileName}`)
26
      })
27

28
      ctx.body = { code: 0, message: '上传成功' }
29
    } catch (err) {
30
      ctx.status = 500
31
      ctx.body = { code: -1, message: '上传失败' }
32
    }
33
  }
34
})
35

36
app.listen(3000)

1
fs.readFile('test.txt', () => {
2
  setImmediate(() => console.log('immediate')) // Check阶段执行
3
  setTimeout(() => console.log('timeout'), 0) // 下一个Timer阶段执行
4
})

1
<template>
2
  <div
3
    ref="container"
4
    class="box"
5
  >
6
    Hello Vue3
7
  </div>
8
</template>
9

10
<script setup>
11
import { ref, onMounted } from 'vue'
12

13
const container = ref(null)
14

15
onMounted(() => {
16
  // DOM刚挂载，直接获取offsetWidth可能不准确（CSS过渡未完成）
17
  queueMicrotask(() => {
18
    const width = container.value.offsetWidth
19
    const height = container.value.offsetHeight
20
    console.log(`容器尺寸：${width}x${height}`)
21
    // 可以做一些基于尺寸的操作，比如调整子组件布局
22
  })
23
})
24
</script>
25

26
<style scoped>
27
.box {
28
  width: 200px;
29
  height: 100px;
30
  transition: width 0.3s;
31
}
32
.box:hover {
33
  width: 300px;
34
}
35
</style>

1
Promise.resolve().then(() => console.log('promise'))
2
queueMicrotask(() => console.log('microtask'))

1
const queue = new FixedQueue() // 环形队列
2

3
function nextTick(callback) {
4
  validateFunction(callback, 'callback')
5

6
  // 处理参数（与setTimeout类似）
7
  let args = []
8
  if (arguments.length > 1) {
9
    args = Array.from(arguments).slice(1)
10
  }
11

12
  // 若队列为空，标记“有Tick任务”
13
  if (queue.isEmpty()) {
14
    setHasTickScheduled(true)
15
  }
16

17
  // 将任务插入队列
18
  queue.push({ callback, args })
19
}

1
const express = require('express')
2
const app = express()
3

4
/**
5
 * 日志中间件：记录请求耗时
6
 */
7
app.use((req, res, next) => {
8
  const start = Date.now()
9
  // 请求完成后触发finish事件
10
  res.on('finish', () => {
11
    // 用process.nextTick在当前Tick间隙执行日志记录
12
    process.nextTick(() => {
13
      const duration = Date.now() - start
14
      console.log(`${req.method} ${req.url} - ${duration}ms`)
15
    })
16
  })
17
  next()
18
})
19

20
app.get('/', (req, res) => {
21
  res.send('Hello Express')
22
})
23

24
app.listen(3000, () => {
25
  console.log('Server running on port 3000')
26
})

1
app.use((req, res, next) => {
2
  const start = Date.now()
3
  res.on('finish', () => {
4
    process.nextTick(() => {
5
      console.log(
6
        `nextTick: ${req.method} ${req.url} - ${Date.now() - start}ms`
7
      )
8
    })
9
    queueMicrotask(() => {
10
      console.log(
11
        `microtask: ${req.method} ${req.url} - ${Date.now() - start}ms`
12
      )
13
    })
14
  })
15
  next()
16
})

1
// 危险：递归调用process.nextTick会导致死循环
2
function loop() {
3
  process.nextTick(loop)
4
}
5
loop()
6

7
setTimeout(() => {
8
  console.log('永远无法执行') // 永远不会输出
9
}, 100)