Q6: setImmediate vs setTimeout(fn, 0) 的执行顺序有什么区别？Node.js 面试题

Node.js 面试题详细答案 - Q6

Q6: setImmediate vs setTimeout(fn, 0) 的执行顺序有什么区别？

基本概念

setImmediate

在事件循环的 check 阶段 执行
在当前事件循环结束后执行
优先级高于 setTimeout

setTimeout(fn, 0)

在事件循环的 timers 阶段 执行
最小延迟为 1ms（实际可能更长）
优先级低于 setImmediate

基本执行顺序

console.log('开始')

setTimeout(() => {
  console.log('setTimeout')
}, 0)

setImmediate(() => {
  console.log('setImmediate')
})

console.log('结束')

// 输出：
// 开始
// 结束
// setImmediate
// setTimeout

详细执行顺序分析

在 I/O 回调中的执行顺序

const fs = require('fs')

fs.readFile(__filename, () => {
  console.log('=== I/O 回调中 ===')

  setTimeout(() => {
    console.log('setTimeout in I/O')
  }, 0)

  setImmediate(() => {
    console.log('setImmediate in I/O')
  })

  console.log('I/O 回调结束')
})

console.log('主线程结束')

// 输出：
// 主线程结束
// === I/O 回调中 ===
// I/O 回调结束
// setImmediate in I/O
// setTimeout in I/O

为什么在 I/O 回调中 setImmediate 先执行？

// 事件循环阶段顺序：
// 1. timers (setTimeout)
// 2. pending callbacks
// 3. idle, prepare
// 4. poll (I/O 操作)
// 5. check (setImmediate)
// 6. close callbacks

// 在 I/O 回调中：
// - 当前在 poll 阶段
// - setImmediate 在下一个 check 阶段执行
// - setTimeout 需要等到下一个 timers 阶段执行
// - 所以 setImmediate 先执行

复杂场景示例

嵌套调用

console.log('1. 开始')

setTimeout(() => {
  console.log('2. setTimeout 外层')

  setTimeout(() => {
    console.log('3. setTimeout 内层')
  }, 0)

  setImmediate(() => {
    console.log('4. setImmediate 内层')
  })
}, 0)

setImmediate(() => {
  console.log('5. setImmediate 外层')

  setTimeout(() => {
    console.log('6. setTimeout 内层')
  }, 0)

  setImmediate(() => {
    console.log('7. setImmediate 内层')
  })
})

console.log('8. 结束')

// 输出：
// 1. 开始
// 8. 结束
// 5. setImmediate 外层
// 7. setImmediate 内层
// 6. setTimeout 内层
// 2. setTimeout 外层
// 4. setImmediate 内层
// 3. setTimeout 内层

与微任务结合

console.log('1. 开始')

setTimeout(() => {
  console.log('2. setTimeout')
}, 0)

setImmediate(() => {
  console.log('3. setImmediate')
})

Promise.resolve().then(() => {
  console.log('4. Promise')
})

process.nextTick(() => {
  console.log('5. process.nextTick')
})

console.log('6. 结束')

// 输出：
// 1. 开始
// 6. 结束
// 5. process.nextTick
// 4. Promise
// 3. setImmediate
// 2. setTimeout

实际应用场景

使用 setImmediate 优化性能

// 使用 setImmediate 分解 CPU 密集型任务
function processLargeArray(array, callback) {
  let index = 0
  const chunkSize = 1000

  function processChunk() {
    const start = Date.now()

    // 处理一小块数据
    while (index < array.length && Date.now() - start < 5) {
      // 处理 array[index]
      processItem(array[index])
      index++
    }

    if (index < array.length) {
      // 让出控制权，避免阻塞事件循环
      setImmediate(processChunk)
    } else {
      callback()
    }
  }

  processChunk()
}

function processItem(item) {
  // 模拟处理单个项目
  return item * 2
}

使用 setTimeout 实现延迟

// 使用 setTimeout 实现真正的延迟
function delayedExecution() {
  console.log('开始延迟执行')

  setTimeout(() => {
    console.log('延迟 100ms 后执行')
  }, 100)

  setTimeout(() => {
    console.log('延迟 200ms 后执行')
  }, 200)

  setImmediate(() => {
    console.log('立即执行（下一个事件循环）')
  })
}

delayedExecution()

性能对比

执行时间对比

// 测试执行时间
function performanceTest() {
  const iterations = 1000000

  // 测试 setTimeout
  console.time('setTimeout')
  for (let i = 0; i < iterations; i++) {
    setTimeout(() => {}, 0)
  }
  console.timeEnd('setTimeout')

  // 测试 setImmediate
  console.time('setImmediate')
  for (let i = 0; i < iterations; i++) {
    setImmediate(() => {})
  }
  console.timeEnd('setImmediate')
}

performanceTest()

最佳实践

何时使用 setImmediate

// 1. 在 I/O 回调中需要立即执行
fs.readFile('file.txt', (err, data) => {
  if (err) throw err

  // 使用 setImmediate 确保在下一个事件循环执行
  setImmediate(() => {
    console.log('文件处理完成')
  })
})

// 2. 分解 CPU 密集型任务
function heavyTask() {
  let result = 0
  let i = 0

  function processChunk() {
    const start = Date.now()
    while (i < 1000000 && Date.now() - start < 5) {
      result += i
      i++
    }

    if (i < 1000000) {
      setImmediate(processChunk)
    } else {
      console.log('任务完成:', result)
    }
  }

  processChunk()
}

何时使用 setTimeout

// 1. 需要真正的延迟
function delayedTask() {
  setTimeout(() => {
    console.log('延迟 1 秒后执行')
  }, 1000)
}

// 2. 需要定时重复执行
function periodicTask() {
  setTimeout(() => {
    console.log('定时任务')
    periodicTask() // 递归调用
  }, 1000)
}

总结

setImmediate：在 check 阶段执行，优先级高，适合立即执行
setTimeout(fn, 0)：在 timers 阶段执行，优先级低，适合延迟执行
执行顺序：在主线程中 setImmediate 先执行，在 I/O 回调中 setImmediate 先执行
使用场景：setImmediate 用于性能优化，setTimeout 用于延迟执行
最佳实践：根据具体需求选择合适的 API