Node.js fs.writeFile() 似乎不是异步的

Question

If we head over to the documentation of Node.js for the fs.writeFile() method , we see that it is asynchronous in nature.

Now, with that in mind, I set up the following code to test this idea:

const fs = require('fs');

function sync(delay) {
    const startingTime = new Date();
    while ((new Date() - startingTime) < delay) {
        // keep this loop going
    }
}


fs.writeFile(__dirname + '/hello.txt', 'Hello World', function() {});

sync(4000);

I have opened the hello.txt file in VSCode, and whenever some data is written to the file, VSCode shows it live.

I expect this code to write Hello World to the file hello.txt , before 4 seconds (which is the delay caused by sync(4000) ) since fs.writeFile() is asynchronous in nature (as the documentation says). However, to my surprise, any data is written to the file after 4 seconds.

This doesn't seem asynchronous at all!

My question is, why isn't the data written to the file hello.txt before the synchronous execution of the whole script.

I suspect (btw, I don't know much about OS threads) that when fs.writeFile() is called, it writes to the file asynchronously (without blocking the main thread) on another OS thread that is free, but this doesn't seem to happen.

I have been testing quite a lot other things related to file-write utilities, such as Writable streams and have seen the same issue. Nothing is written unless and until all of the synchronous execution completes.

I need a clear explanation on this kind-of internal thing.

Answer 1

Try this:

import { writeFile } from 'fs/promises'

function sync(delay) {
  const startingTime = new Date();
  while ((new Date() - startingTime) < delay) {
      // keep this loop going
  }
}

(async () => {
  await writeFile(__dirname + '/hello.txt', 'Hello World');

  sync(4000)
})();

Answer 2

Although writeFile may seem asynchronous in behavior, NodeJS is limited by the fact that JavaScript is a single-threaded language. To simulate being asynchronous, NodeJS uses the event loop in order to process actions.

I'm not sure exactly on the inner workings of the writeFile function, but judging from how the code runs it can be assumed that 3 or more tasks are being added to the event loop (one for creating the file, one for writing to the created file, and one for processing the callback). The multiple events are important to understanding why the code executes the way it does.

When the writeFile function call executes, the 'hello.txt' file is generated empty (creating the file, the first task). However, since the writeFile call was executed, the JavaScript engine has already moved on and executed the culprit of the problem, your sync function. The sync function utilizing a while loop to simulate a delay rather than the normally used setTimeout function is key to understanding what is going on internally.

What the while loop is doing in this scenario is hijacking the event loop before writing to the file that was created (which explains why the file is created but not written to) due to while being a blocking operation. You can verify this behavior by adding another I/O operation using writeFileSync before your sync function. Both files will be created but only the writeFileSync function's file would have anything written in it.

Due to the while loop blocking the event loop, the data is written to the file after your delay because that is when the while loop finishes executing and frees up the event loop in order to execute the final tasks of the writeFile function.

Note: This answer was written with a degree of uncertainty as I haven't explored the internals of how the NodeJS event loop works thoroughly. The documents I referenced in answering this question are here:

• Don't Block The Event Loop
• Overview of Blocking vs Non-Blocking
• The Node.js Event Loop