next → ← prev

Callback Queue

Last Updated : 29 Aug 2026

Asynchronous Programming

Asynchronous programming allows a program to continue to run other codes while waiting for an already running task to complete. The running task is executed in the background while the rest of the code is prioritized.

In single-threaded environments such as JavaScript, asynchronous operations (timer delays, network requests, or file I/O) are offloaded to host environment APIs (for example, Browser Web APIs or Node.js C++ APIs). Once complete, the results are processed using callback functions passed as arguments to be executed later.

The Callback Queue

The Callback Queue also known as the Task Queue or Event Queue based on FIFO (First-In, First-Out) data structure that holds callbacks ready for execution.

When an asynchronous background task completes, its corresponding callback is moved into the Callback Queue, where it waits in line until the main execution thread is free to process it.

The Event Loop

The Event Loop is the orchestration mechanism that connects the Call Stack and the Callback Queue.

It continuously monitors two conditions:

1. Is the Call Stack empty?
2. Are there pending callbacks in the Callback Queue?

If the stack is empty, the Event Loop takes the first callback from the Callback Queue and pushes it onto the Call Stack, executing it safely without causing race conditions or blocking user interactions.

Algorithm(Pseudocode)

function main(): initialize() while message != quit: message := get_next_message() process_message(message) end while end function

JavaScript Implementation

console.log('Starting app');
setTimeout(() => {
    console.log('Inside of callback');
}, 2000);
setTimeout(() => {
    console.log('Second setTimeout');
}, 0);
console.log('Finishing up');

Compile and Run

Output:

Starting app
Finishing up
Second setTimeout
Inside of callback

Explanation

Starting app runs synchronously and logs immediately. setTimeout(..., 2000) registers a timer with the Web API and sets a 2-second delay. setTimeout(..., 0) registers a 0ms timer. Even though its timer completes instantly, its callback is moved to the Callback Queue and must wait for the main thread to clear.

Finishing up logs synchronously. The Call Stack is now empty. The Event Loop pulls Second setTimeout from the queue and executes it. After 2 seconds, the first timer's callback arrives in the queue and is executed (Inside of callback).

Purpose of using Callback Queue

• Non-Blocking Event Handling: Manages user input (clicks, keypresses) and system events sequentially without freezing the UI.
• Managed Asynchronous Execution: Ensures operations dependent on network, database, or disk I/O trigger their continuation code only after the data is fully available.
• Predictable Concurrency: Keeps execution single-threaded and deterministic, preventing common multithreading issues like race conditions or memory deadlocks.

Execution Lifecycle

1. Initiation & Registration: The main program triggers an asynchronous operation and registers its callback function with the host environment.
2. Background Processing: The host environment handles the task (e.g., waiting for a timer or fetching API data) in the background while the main call stack continues running synchronous code.
3. Queueing: Upon completion of the background task, the host places the callback into the Callback Queue.
4. Event Loop Pick-up: The Event Loop checks if the Call Stack is completely clear. If so, it dequeues the oldest callback and moves it onto the Call Stack.
5. Completion: The callback executes to completion, and the process repeats for subsequent items in the queue.