Node.js HTTP多请求调用同一函数时数据异常问题求助

Hey there! Let's dig into why your Node.js HTTP requests are interfering with each other and how to fix that per-request isolation issue you're aiming for.

First, a quick recap: Node.js runs on a single-threaded event loop, which means all incoming HTTP requests are processed in the same memory space. While asynchronous operations (like database calls or timeouts) don't block the loop, any shared mutable state across requests will cause interference. This is because all requests have access to the same global/module-level variables, leading to race conditions when those variables get modified concurrently.

Common Causes of Request Interference #

Let's break down the most frequent culprits:

• Shared global/module-level variables: If you define a variable outside your request handler function, every request will read and modify the same instance. Here's a classic example of how this goes wrong:

  // ❌ Bad: Shared mutable state
  let requestData = {};
  
  function handleRequest(req, res) {
    requestData.userId = req.query.userId;
    // Simulate an async operation (e.g., database fetch)
    setTimeout(() => {
      res.end(`Processing user: ${requestData.userId}`);
    }, 100);
  }
  

  If two requests hit this endpoint at the same time—first ?userId=1, then ?userId=2—the second request will overwrite requestData.userId before the first's timeout completes. The first response will incorrectly return "Processing user: 2" instead of 1.

• Unencapsulated shared resources: If you're using a singleton object (like a custom database client with internal state) across all requests, any state changes in that object will leak between requests.

Here's how to ensure each request uses its own independent resources:

1. Create Request-Specific State Inside the Handler #

Move all mutable state into the request handler function itself. This way, every incoming request gets its own copy of the data:

// ✅ Good: Request-local state
function handleRequest(req, res) {
  // Each request gets its own requestData object
  const requestData = { userId: req.query.userId };
  setTimeout(() => {
    res.end(`Processing user: ${requestData.userId}`);
  }, 100);
}

No more overwrites—each request's data stays isolated to its own function scope.

2. Mount Resources to the Request Object (For Frameworks Like Express) #

If you're using Express or similar frameworks, you can attach request-specific resources directly to the req object. This makes the resources accessible across middleware and handlers while keeping them isolated to the current request:

// Express example: Attach request-specific context
app.use((req, res, next) => {
  // Create a unique context for this request
  req.requestContext = {
    userId: req.query.userId,
    // Add other per-request resources here (e.g., a dedicated DB connection if needed)
  };
  next();
});

app.get('/', (req, res) => {
  setTimeout(() => {
    res.end(`Processing user: ${req.requestContext.userId}`);
  }, 100);
});

3. Avoid Stateful Singletons #

If you need to use shared resources (like database connections), make sure they're stateless. For example, database connection pools are safe because each request borrows an independent connection from the pool, uses it, and returns it—no shared state between requests. Avoid custom singleton objects that store request-specific data.

• Request interference almost always boils down to shared mutable state in global/module scope.
• Keep all request-specific data and resources in the handler's local scope or attached to the req object.
• Async operations don't cause interference on their own—they only reveal issues when shared state is involved.

If you can share a snippet of your actual code, we can pinpoint the exact source of the interference, but following these steps should resolve most per-request isolation issues.

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