Node.js setTimeout回调疑问：为何超时后批量触发？

Great question—this is a super common point of confusion when first diving into Node.js's asynchronous behavior, so let's break this down clearly.

First, Why All Deliveries Happen Simultaneously #

Let's walk through exactly what your code does step by step:

1. When you call placeAnOrder(1), it immediately logs "Order placed 1", then calls cookAndDeliver. Inside that function, setTimeout(callback, 5000) tells Node.js: "Add this callback to the event queue in 5 seconds."
2. Node.js doesn't wait around for that timeout to finish—it's non-blocking by design! So it jumps straight to executing placeAnOrder(11), which does the exact same thing: logs the order, and schedules another callback for 5 seconds from right now.
3. This repeats for all 5 orders. By the time all placeAnOrder calls finish, Node.js has 5 separate callbacks all scheduled to run at the exact same moment (5 seconds after the program started).

When that 5-second mark hits, all 5 callbacks get added to the event queue. Since Node.js's main thread is free at that point, it runs them one after another—so you see all "Delivered order" logs pop up almost instantly, like they're happening at the same time.

Your Thread Hypothesis: Let's Correct That #

Nope, Node.js doesn't use a separate thread for each call! It operates on a single-threaded event loop model. Here's the key breakdown:

• The main thread runs your synchronous code (like the console.log("Order placed...") calls) one line at a time.
• Asynchronous operations (like setTimeout) are offloaded to a background worker pool (managed by libuv), but the callback itself waits in the event queue until the main thread is free.
• When the timeout finishes, the callback isn't executed immediately—it's added to the queue. The main thread will only process it once it's done with all synchronous work.

So in your code, all 5 timeouts are scheduled in quick succession, their callbacks all hit the queue at the same time, and the main thread runs them back-to-back.

How to Make Orders Deliver One After Another #

If you want each order to start its 5-second timer after the previous one is delivered, you need to chain the asynchronous operations. Here are a couple clean ways to do that:

Option 1: Nested Callbacks (Classic Approach)

function placeAnOrder(orderNumber, nextOrder) {
  console.log("Order placed", orderNumber);
  cookAndDeliver(function () {
    console.log("Delivered order", orderNumber);
    // Only start the next order after this one is done
    if (nextOrder) nextOrder();
  });
};

function cookAndDeliver(callback){
  setTimeout(callback, 5000);
};

// Chain the orders sequentially
placeAnOrder(1, function() {
  placeAnOrder(11, function() {
    placeAnOrder(111, function() {
      placeAnOrder(1111, function() {
        placeAnOrder(11111, null);
      });
    });
  });
});

Option 2: Promises + Async/Await (Cleaner Modern Approach)

// Wrap cookAndDeliver in a Promise to use async/await
function cookAndDeliver() {
  return new Promise(resolve => {
    setTimeout(resolve, 5000);
  });
}

// Process orders one at a time with async/await
async function processOrders() {
  const orders = [1, 11, 111, 1111, 11111];
  
  for (const order of orders) {
    console.log("Order placed", order);
    await cookAndDeliver(); // Wait 5 seconds before moving to the next order
    console.log("Delivered order", order);
  }
  
  console.log("All orders have been delivered!");
}

processOrders();

With either of these, each order's 5-second timer starts only after the previous order is marked as delivered, so you'll see one delivery log every 5 seconds instead of all at once.

内容的提问来源于stack exchange，提问作者WiredCoder