Understanding Node.js Asynchronous Execution Model and async_hooks

Node.js uses a single‑threaded JavaScript execution model and off‑loads I/O to background workers; callbacks are queued and executed later, preventing blocking of the main thread.

The article introduces an “asynchronous continuation model” that defines execution frames, continuations, continuation points, link points, and ready points, describing how they form a logical chain of asynchronous operations.

An event‑flow example with console.log , Promise , and setTimeout demonstrates the sequence of events: executionBegin , link , executionEnd , ready , and subsequent execution phases.

The built‑in async_hooks module implements this model, providing lifecycle hooks such as init , before , after , and destroy to track asynchronous resources.

A comparison with the deprecated domain module highlights that async_hooks describes resource semantics while domain focuses on error handling, and notes that domain often leads to hard‑to‑debug issues.

For native add‑ons, the article shows how to preserve the async‑hook chain using N‑API functions like napi_threadsafe_function . Sample C code is provided:

#include <assert.h>
#include <node_api.h>

void async_call_js(napi_env env, napi_value js_callback, void* context, void* data) {
  napi_status status;
  // Convert data to a JavaScript value
  napi_value value = transform(env, data);
  napi_value recv;
  status = napi_get_null(env, &amp;recv);
  assert(status == napi_ok);
  // Safe call after N‑API has bound the async resource
  napi_value ret;
  status = napi_call_function(env, recv, js_callback, 1, &amp;value, &amp;ret);
  assert(status == napi_ok);
}

void do_work(napi_threadsafe_function tsfn) {
  // Work performed in a worker thread
  napi_status status = napi_call_threadsafe_function(tsfn, data, napi_tsfn_nonblocking);
  assert(status == napi_ok);
}

napi_value some_module_method(napi_env env, napi_callback_info info) {
  napi_status status;
  napi_threadsafe_function tsfn;
  status = napi_create_threadsafe_function(env, func, async_resource, async_resource_name,
                                           max_queue_size, initial_thread_count,
                                           finalize_data, finalize_cb, context,
                                           call_js_cb, &amp;tsfn);
  assert(status == napi_ok);
  create_worker(tsfn, /** other params */);
  napi_value ret;
  status = napi_get_null(env, &amp;ret);
  assert(status == napi_ok);
  return ret;
}

Use‑case examples include tracking dangling async tasks in unit tests, building async call‑stack visualizations, and using AsyncLocalStorage (added in Node v13.10.0) to store per‑request context across asynchronous boundaries.

Finally, the article discusses the need for better tooling to expose async timelines in browsers and APM systems, noting that async_hooks exposes low‑level properties that are powerful but not easy for most developers.