事件循环处理的回调是否完成？

Question

I understood through NodeJS's Event Loop documentation that the callbacks handled by the event loop are completed tasks.

Is it correct that Libuv's thread handles asynchronous work, and when it's done, the event loop pulls the work from the event queue and just returns a callback?

Because the callback I understand is the action to be performed after the job is done.

If that assumption is correct, when can the event loop block?

Also, it doesn't make sense that the event queue and event loop are used just for callback execution after the job is done.

What am I misunderstanding?

Answer 1

Is it correct that Libuv's thread handles asynchronous work

Some asynchronous work is handled by libuv threads, some is not. For example networking uses OS APIs that already work asynchronously and does not use or need threads. nodejs has its own timer implementation that does not use threads.

and when it's done, the event loop pulls the work from the event queue and just returns a callback?

When an asynchronous job is done, it inserts an event into the event queue. When it is that event's turn to get pulled from the event queue, then it will trigger a callback to get called.

If that assumption is correct, when can the event loop block?

The event loop is blocked anytime a callback from the prior event is still executing. Events are processed one at a time.

Also, it doesn't make sense that the event queue and event loop are used just for callback execution after the job is done.

I'm not sure exactly where your confusion is here. When an event is processed a callback is called and it starts to run. If the work that is being done has further asynchronous work, then that callback will start one or more additional asynchronous operations and then it will return back to the event queue (the callback will return).

At this point, the work that operation wants to complete is not yet fully done (there are some new outstanding asynchronous operations), but as far as the event loop is concerned, that callback returned and that callback itself is done so the event loop finds the next event ready to be run.

At some future point, those asynchronous operations that were just started will finish and will insert an event into the event loop when they get called that higher level operation will make further progress toward its eventual goal. So, in this way, a series of asynchronous operations in service of some higher level operation do not block the event loop during the whole duration, only during small slivers of execution along the way with opportunities for other things to run when the larger operation is waiting for asynchronous operations to complete.