Why does fs.readFile complete in the first thread-pool wave, ahead of pbkdf2 tasks queued before it?

[ganeshdevnr]

Summary

With the default libuv thread pool size (4), I fire six crypto.pbkdf2() calls and one fs.readFile() of a small, already-cached file in the same synchronous tick. The six pbkdf2 calls are issued before the fs.readFile call. I expected the readFile callback to complete after the pbkdf2 work, but it consistently lands in the first wave of completions, while two of the pbkdf2 tasks are pushed to a later wave.

Environment

• Node.js: v22.22.3
• • OS: macOS
• • UV_THREADPOOL_SIZE: unset (default 4)

Reproduction

const crypto = require('crypto');
const fs = require('fs');

const start = Date.now();
const t = () => `+${Date.now() - start}ms`;

for (let i = 1; i <= 6; i++) {
  crypto.pbkdf2('password', 'salt', 100000, 64, 'sha512', () => {
    console.log(`pbkdf2 ${i} done at ${t()}`);
  });
}

fs.readFile(__filename, () => {
  console.log(`readFile done at ${t()}`);
});

Observed output

pbkdf2 3 done at +22ms
pbkdf2 4 done at +24ms
pbkdf2 2 done at +24ms
pbkdf2 1 done at +24ms
readFile done at +24ms
pbkdf2 5 done at +42ms
pbkdf2 6 done at +42ms

The four-then-two split for the pbkdf2 tasks matches the 4-thread pool as expected.

Question

Given that all six pbkdf2 calls are submitted before fs.readFile in the same tick, why does the readFile callback complete in the first wave (~24ms) rather than after pbkdf2 5 and 6?

I'm trying to build an accurate mental model of how the thread pool orders and schedules this work. A pointer to where in the source this ordering is determined would be much appreciated. Thanks!