《Node 8 The Right Way》中zmq-filer-req-loop.js输出交错问题问询

Hey there! Let me clear up this confusion for you—it ties into two key pieces of how your code works: Node.js's asynchronous event loop and ZeroMQ's REQ socket behavior.

First, let's address your core assumption: you thought all requests would finish sending (and the main file would wrap up execution) before any callbacks fired. That's not quite how Node.js operates, and there's a ZeroMQ-specific rule driving the interleaved output you're seeing in the book's example.

1. ZeroMQ's REQ Socket Enforces a Strict Request-Response Flow #

The req socket type has a non-negotiable rule: you can only send one request at a time, and you must wait for the corresponding response before sending another. If you try to blast through multiple requests in a synchronous loop (without waiting for responses), you'll hit weird behavior or errors—ZeroMQ blocks additional sends until the pending response comes back.

The code in zmq-filer-req-loop.js is almost certainly structured to send the next request only after receiving the previous response. Here's a simplified version of that pattern:

const zmq = require('zmq');
const requester = zmq.socket('req');
let currentRequest = 1;
const maxRequests = 2;

requester.connect('tcp://localhost:5555');

// Kick off the first request
sendNextRequest();

function sendNextRequest() {
  if (currentRequest > maxRequests) return;
  console.log(`Sending request ${currentRequest}`);
  requester.send(`request ${currentRequest}`);
}

// Handle responses, then trigger the next request
requester.on('message', (response) => {
  console.log(`Receive response for request ${currentRequest}`);
  currentRequest++;
  sendNextRequest();
});

2. Why the Output Looks Interleaved #

With this setup, the flow plays out like this:

• The main script runs, sends the first request, then finishes executing its synchronous code.
• When the server sends back a response for request 1, Node.js pulls the message callback from its event queue and runs it. This logs the response, increments the request number, and sends the next request.
• The cycle repeats for request 2.

This results in the back-and-forth output you saw:

Sending request 1
Receive response for request 1
Sending request 2
Receive response for request 2

3. Why Your Initial Assumption Was Off #

You expected all requests to go out first, then all responses to come in. But because of the REQ socket's rules, you can't batch-send requests—you have to wait for each response before moving to the next. Node.js's event loop handles the "waiting" asynchronously: while it's waiting for a response, it's free to handle other tasks, but in this case, the only next task is sending the next request once the response arrives.

If you tried to ignore the REQ socket rules and send requests in a synchronous loop, you'd either get errors or have all requests buffered until responses start coming in—but that's not the intended use of the REQ socket, and it's not what the book's example is doing.

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