Node.js 定时器与事件循环：setTimeout、setInterval 及 process.nextTick 深度解析

Node.js 定时器基础：setTimeout 与 setInterval

熟悉前端 JavaScript 开发的开发者通常对 setTimeout 和 setInterval 并不陌生，它们用于在指定延迟后执行代码。例如，以下代码在页面加载后 1 秒，会在文档末尾追加一段文本“Hello there”：

var oneSecond = 1000 * 1; // one second = 1000 x 1 ms
setTimeout(function() {
document.write('<p>Hello there.</p>');
}, oneSecond);

而 setInterval 则允许以固定时间间隔重复执行函数。若将以下代码嵌入网页，它将每秒向文档追加一次“Hello there”：

var oneSecond = 1000 * 1; // one second = 1000 x 1 ms
setInterval(function() {
document.write('<p>Hello there.</p>');
}, oneSecond);

随着 Web 应用从静态页面演变为复杂的应用平台，此类定时需求日益增多。这些定时函数帮助开发者实现表单定期校验、延迟远程数据同步或需要延时响应的 UI 交互。Node.js 完整实现了这些 API。在服务器端，它们可用于缓存过期处理、连接池清理、会话管理、轮询等多种任务。

深入理解 setTimeout：执行计划与取消机制

使用 setTimeout 延迟函数执行

setTimeout 用于设定一个在未来特定时间执行一次函数的计划，示例如下：

var timeout_ms = 2000; // 2 seconds
var timeout = setTimeout(function() {
console.log("timed out!");
}, timeout_ms);

与客户端 JavaScript 一致，setTimeout 接收两个参数：第一个是待延迟执行的函数，第二个是延迟时间（毫秒）。

setTimeout 返回一个超时句柄，这是一个内部对象。你可以将其作为参数传递给 clearTimeout 来取消计时器，除此之外该句柄无其他用途。

使用 clearTimeout 取消执行计划

获取超时句柄后，即可通过 clearTimeout 取消函数执行计划，如下所示：

var timeoutTime = 1000; // one second
var timeout = setTimeout(function() {
console.log("timed out!");
}, timeoutTime);
clearTimeout(timeout);

在此示例中，计时器永远不会触发，也不会输出“time out!”。你也可以在后续任意时刻取消计划，例如：

var timeout = setTimeout(function A() {
 
console.log("timed out!");
 
}, 2000);
 
setTimeout(function B() {
 
clearTimeout(timeout);
 
}, 1000);

代码定义了两个延时函数 A 和 B。A 计划在 2 秒后执行，B 在 1 秒后执行。由于 B 先执行并取消了 A 的计划，因此 A 永远不会运行。

setInterval 的重复执行与取消策略

制定和取消函数的重复执行计划

setInterval 与 setTimeout 类似，但以指定时间间隔重复执行函数。它适用于周期性触发清理、收集日志、获取数据或轮询等任务。

以下代码每秒向控制台输出一句“tick”：

var period = 1000; // 1 second
setInterval(function() {
console.log("tick");
}, period);

若需停止运行，可使用 clearInterval() 取消定时器。

setInterval 返回一个执行计划句柄，可作为 clearInterval 的参数来取消计划：

var interval = setInterval(function() {
console.log("tick");
}, 1000);
                   // …
clearInterval(interval);

process.nextTick：优化事件循环性能的关键

使用 process.nextTick 将函数执行延迟到事件循环的下一轮

前端开发者有时使用 setTimeout(callback, 0) 将任务延迟极短时间，即所有挂起事件处理完毕后立即执行回调。这种技术常用于延迟执行非即时操作，例如在用户事件处理后播放动画或进行其他计算。

在 Node.js 中，事件循环处理事件队列，每一轮循环称为一个 tick。

你可以在每次事件循环开始下一轮（下一个 tick）时调用回调函数，这正是 process.nextTick 的原理。相比之下，setTimeout 使用 JavaScript 运行时的内部执行队列，而非事件循环本身。

使用 process.nextTick(callback) 替代 setTimeout(callback, 0)，回调函数会在队列内事件处理完毕后立即执行，其速度远快于 JavaScript 超时队列（以 CPU 时间衡量）。

你可以按以下方式将函数延迟到下一轮事件循环运行：

process.nextTick(function() {
my_expensive_computation_function();
                   });

注意：process 对象是 Node.js 为数不多的全局对象之一。

警惕 CPU 密集型操作对事件循环的阻塞

堵塞事件循环

Node.js 和 JavaScript 运行时采用单线程事件循环。每次循环中，运行时通过调用相关回调函数处理队列中的下一个事件。事件执行完毕后，事件循环获取结果并处理下一事件，直到队列为空。若某个回调函数耗时过长，事件循环在此期间无法处理其他挂起事件，导致应用或服务变得缓慢。

若在处理事件时使用了内存或 CPU 敏感的函数，会导致事件循环变慢，大量事件堆积无法及时处理，甚至堵塞队列。

以下示例展示了如何堵塞事件循环：

process.nextTick(function nextTick1() {
var a = 0;
while(true) {
a ++;
                            }
                   });
process.nextTick(function nextTick2() {
console.log("next tick");
                   });
setTimeout(function timeout() {
console.log("timeout");
}, 1000);

此例中，nextTick2 和 timeout 函数无论等待多久都无法运行，因为事件循环被 nextTick1 中的无限循环堵塞。即使 timeout 计划在 1 秒后执行，它也不会运行。

使用 setTimeout 时，回调函数会被添加到执行计划队列，而在此例中它们甚至未被加入队列。虽然这是极端情况，但可见运行 CPU 敏感任务可能会堵塞或拖慢事件循环。

利用 process.nextTick 释放事件循环

退出事件循环

使用 process.nextTick 可将非关键性任务推迟到事件循环的下一轮 (tick) 执行，从而释放事件循环，使其继续处理其他挂起事件。

以下示例中，若需删除临时文件但不想让 data 事件的回调函数等待该 IO 操作，可将其延迟：

stream.on("data", function(data) {
stream.end("my response");
process.nextTick(function() {
fs.unlink("/path/to/file");
                            });
                   });

使用递归 setTimeout 实现串行定时任务

使用 setTimeout 替代 setInterval 来确保函数执行的串行性

假设你设计一个名为 my_async_function 的函数，用于执行某些 I/O 操作（如解析日志文件），并希望周期性执行。你可以使用 setInterval 实现：

var interval = 1000;
setInterval(function() {
my_async_function(function() {
console.log('my_async_function finished!');
                            });
},interval);//译者注：前面“,interval”是我添加的，作者应该是笔误遗漏了

你必须确保这些函数不会同时执行。然而，使用 setInterval 无法保证这一点。如果 my_async_function 运行时间比 interval 变量多出 1 毫秒，它们就会同时执行，而非按顺序串行执行。

译者注：（下面粗体部分为译者添加，非原书内容）

为方便理解，可修改作者代码使其实际运行：

var interval = 1000;
setInterval(function(){
(function my_async_function(){
setTimeout(function(){
console.log("1");
},5000);
                           })();
},interval);

运行此代码，你会发现等待 5 秒后，“hello ”每隔 1 秒输出一次。而我们期望的是：当前 my_async_function 执行完毕（耗时 5 秒）后，等待 1 秒再执行下一个 my_async_function，每次输出间隔应为 6 秒。造成此结果的原因是 my_async_function 并非串行执行，而是多个同时运行。

因此，你需要一种方法强制使一个 my_async_function 执行结束到下一个开始之间的间隔时间正好是 interval 变量指定的时间。你可以这样做：

var interval = 1000; // 1 秒
(function schedule() { //第3行
setTimeout(function do_it() {
my_async_function(function() { //第5行
console.log('async is done!');
schedule();
                                     });
}, interval);
}()); //第10行

前述代码中，声明了一个名为 schedule 的函数（第 3 行），并在声明后立即调用它（第 10 行）。schedule 函数会在 1 秒（由 interval 指定）后运行 do_it 函数。1 秒后，第 5 行的 my_async_function 被调用，执行完毕后调用其匿名回调函数（第 6 行），该匿名回调函数再次重置 do_it 的执行计划，使其 1 秒后重新执行。这样代码便开始串行地不断循环执行。

小结

可使用 setTimeout() 预先设定函数执行计划，并用 clearTimeout() 取消。也可用 setInterval() 周期性重复执行函数，并使用 clearInterval() 取消该计划。

若因使用 CPU 敏感操作而堵塞事件循环，原计划执行的函数将被延迟甚至无法执行。因此，不要在事件循环内使用 CPU 敏感操作。此外，可使用 process.nextTick() 将函数执行延迟到事件循环的下一轮。

I/O 与 setInterval() 配合使用时，无法保证任何时间点只有一个挂起调用。但你可以使用递归函数和 setTimeout() 来回避这一棘手问题。