10,000 concurrent users = 10,000 threads
Each thread = ~2MB RAM
Total = 20GB RAM just for thread overhead!

10,000 users hit the site simultaneously.
Each request needs:
  1. Read user profile (DB query: 50ms)
  2. Fetch order history (DB query: 100ms)
  3. Calculate recommendations (DB query: 200ms)
  4. Render the page (CPU: 5ms)

Multi-Threaded Server:
  10,000 threads × (50 + 100 + 200 + 5)ms of waiting = DROWNING

Node.js Server:
  1 thread × 5ms CPU + non-blocking DB queries = 🚀 SMOOTH SAILING

MULTI-THREADED (Blocking I/O)
═══════════════════════════════
Time → 0ms      50ms     100ms    150ms    200ms
Req1   [───DB Query────]                         ← Thread 1 blocked
Req2        [───DB Query────]                    ← Thread 2 blocked
Req3             [───DB Query────]               ← Thread 3 blocked
CPU                           [░░░░]             ← Only now actual work

NODE.JS (Non-Blocking I/O)
═══════════════════════════
Time → 0ms      50ms     100ms    150ms    200ms
Req1   [DB──]                                  ← Start query, don't wait
Req2   [DB──]                                  ← Start another
Req3   [DB──]                                  ← Start another
CPU    [░░]    [░░]     [░░]     [░░]     [░░] ← Use wait time for CPU work
               ↑ DB1 done → callback runs here
                        ↑ DB2 done → callback runs here
                                  ↑ DB3 done → callback runs here

flowchart TB
    subgraph App["Application Layer (JavaScript)"]
        AppCode["Your Code\n(app.js, routes, controllers)"]
        NodeAPI["Node.js APIs\n(fs, http, path, crypto, events, stream)"]
    end

    subgraph Bridge["C++ Bridge Layer"]
        Bindings["Node.js Bindings\n(JS → C++ function calls)"]
    end

    subgraph Runtime["Runtime Layer"]
        V8["V8 JavaScript Engine\n• Parse JS → AST\n• Compile → Machine Code\n• Garbage Collection\n• Memory Management"]
        libuv["libuv (C Library)\n• Event Loop\n• Thread Pool\n• Async I/O\n• Timer Management"]
    end

    subgraph System["Operating System"]
        Kernel["OS Kernel\n• epoll (Linux)\n• kqueue (macOS)\n• IOCP (Windows)"]
        Hardware["CPU | RAM | Disk | Network"]
    end

    AppCode --> NodeAPI
    NodeAPI --> Bindings
    Bindings --> V8
    Bindings --> libuv
    libuv --> Kernel
    V8 --> Kernel
    Kernel --> Hardware

    style App fill:#4f46e5,color:#fff
    style Bridge fill:#6366f1,color:#fff
    style Runtime fill:#7c3aed,color:#fff
    style V8 fill:#f59e0b,color:#fff
    style libuv fill:#10b981,color:#fff
    style System fill:#dc2626,color:#fff

// Simplified libuv Event Loop (written in C)
int uv_run(uv_loop_t* loop) {
  while (uv_loop_alive(loop)) {
    // 1. Timers: Run expired setTimeout/setInterval callbacks
    uv__run_timers(loop);

    // 2. Pending I/O: Run callbacks from completed I/O
    uv__run_pending(loop);

    // 3. Idle/Prepare: Internal housekeeping
    uv__run_idle(loop);
    uv__run_prepare(loop);

    // 4. Poll: Wait for new I/O events (blocking)
    uv__io_poll(loop, timeout);

    // 5. Check: Run setImmediate callbacks
    uv__run_check(loop);

    // 6. Close: Run close callbacks
    uv__run_closing_handles(loop);
  }
  return 0;
}

flowchart TB
    Start["▶️ Start"] --> Timers

    subgraph Phases["Event Loop Cycle (6 Phases)"]
        Timers["1️⃣ Timers Phase\nsetTimeout / setInterval\ncallbacks execute here"]
        Pending["2️⃣ Pending I/O\nI/O callbacks from\nprevious operations"]
        Idle["3️⃣ Idle/Prepare\nInternal use only\n(not accessible from JS)"]
        Poll["4️⃣ Poll Phase\nGet new I/O events\nExecute I/O callbacks\n**Most important phase**"]
        Check["5️⃣ Check Phase\nsetImmediate\ncallbacks execute here"]
        Close["6️⃣ Close Phase\nClose event callbacks\n(socket.on('close'), etc.)"]
    end

    Timers --> Pending --> Idle --> Poll --> Check --> Close
    Close -->|"Next Cycle"| Timers

    Microtasks["⚡ Microtask Queues\nprocess.nextTick() → High Priority\nPromise.then/catch → Medium Priority\nRun BETWEEN every phase"]

    Microtasks -.-> Timers
    Microtasks -.-> Pending
    Microtasks -.-> Poll
    Microtasks -.-> Check
    Microtasks -.-> Close

    style Timers fill:#4f46e5,color:#fff
    style Pending fill:#6366f1,color:#fff
    style Idle fill:#818cf8,color:#fff
    style Poll fill:#059669,color:#fff
    style Check fill:#d97706,color:#fff
    style Close fill:#dc2626,color:#fff
    style Microtasks fill:#10b981,color:#fff
    style Start fill:#7c3aed,color:#fff

flowchart LR
    subgraph Blocking["❌ Blocking I/O (Sync)"]
        Call1["call fs.readFileSync()"] --> Wait1["⏸️ Thread BLOCKED\nwaiting for disk I/O"]
        Wait1 --> Resume1["▶️ Resume execution"]
        Resume1 --> End1["✅ Done (but wasted time)"]
    end

    subgraph NonBlocking["✅ Non-Blocking I/O (Async)"]
        Call2["call fs.readFile()"] --> Return2["🔄 Returns immediately\n(Promise/callback registered)"]
        Return2 --> Continue2["▶️ Continue executing\nother JavaScript code"]
        Continue2 --> Callback2["🔔 OS notifies libuv\n→ callback queued\n→ runs on next phase"]
        Callback2 --> End2["✅ Done (no wasted time)"]
    end

    style Blocking fill:#ef4444,color:#fff
    style NonBlocking fill:#10b981,color:#fff

sequenceDiagram
    participant JS as JavaScript
    participant EL as Event Loop
    participant libuv as libuv Thread Pool
    participant OS as OS (Disk/Network)

    Note over JS,OS: Consider this code:
    Note over JS,OS: console.log('1')
    Note over JS,OS: setTimeout(() => console.log('2'), 0)
    Note over JS,OS: fs.readFile('file.txt', cb)
    Note over JS,OS: console.log('3')

    JS->>JS: Execute console.log('1')
    JS->>EL: Register setTimeout(fn, 0)
    JS->>EL: Register fs.readFile()
    EL->>libuv: Delegate file read to thread pool
    JS->>JS: Execute console.log('3')

    Note over JS: All synchronous code done!

    EL->>EL: Check Microtask Queue (empty)
    EL->>EL: Enter Timers Phase
    EL->>JS: Execute setTimeout callback
    JS->>JS: console.log('2')

    EL->>EL: Enter Poll Phase (waiting for I/O)
    libuv->>EL: 🔔 File read complete!
    EL->>JS: Execute fs.readFile callback

    EL->>EL: No more work → exit

// Execution priority in Node.js (HIGH to LOW):
// 1. process.nextTick()    ← HIGHEST
// 2. Promise.then/catch    ← SECOND
// 3. setTimeout(fn, 0)     ← TIMER PHASE
// 4. setImmediate()        ← CHECK PHASE (AFTER I/O)

console.log('1 - Synchronous');

setTimeout(() => {
  console.log('4 - setTimeout (Timer Phase)');
}, 0);

setImmediate(() => {
  console.log('5 - setImmediate (Check Phase)');
});

Promise.resolve().then(() => {
  console.log('3 - Promise.then (Microtask)');
});

process.nextTick(() => {
  console.log('2 - process.nextTick (Microtask - HIGHEST)');
});

console.log('6 - Synchronous End');

// OUTPUT:
// 1 - Synchronous
// 6 - Synchronous End
// 2 - process.nextTick (Microtask - HIGHEST)
// 3 - Promise.then (Microtask)
// 4 - setTimeout (Timer Phase)
// 5 - setImmediate (Check Phase)

const fs = require('fs');

fs.readFile(__filename, 'utf-8', () => {
  console.log('1 - I/O callback (Poll Phase)');

  setTimeout(() => {
    console.log('2 - setTimeout inside I/O');
  }, 0);

  setImmediate(() => {
    console.log('3 - setImmediate inside I/O');
  });
});

// ─── INSIDE I/O callback, setImmediate ALWAYS runs before setTimeout ───
// OUTPUT:
// 1 - I/O callback (Poll Phase)
// 3 - setImmediate inside I/O
// 2 - setTimeout inside I/O

// ─── WHY? When inside I/O callback:
// Poll Phase → Check Phase (setImmediate) → Timers Phase (setTimeout)

let count = 0;

function recursiveNextTick() {
  process.nextTick(() => {
    count++;
    if (count < 100000) {
      recursiveNextTick();  // Keeps adding to microtask queue
    }
  });
}

// Start
setTimeout(() => {
  console.log('This may take a while to print...');
}, 100);

recursiveNextTick();

// ─── PROBLEM ───
// The recursive nextTick keeps the microtask queue full.
// The Event Loop NEVER reaches the Timer Phase.
// The setTimeout callback is STARVED indefinitely!

// ─── FIX ───
function fixedRecursive() {
  setImmediate(() => {      // Use setImmediate instead
    count++;
    if (count < 100000) {
      fixedRecursive();     // Check Phase → Poll → Timers → allows others to run
    }
  });
}

const http = require('http');
const { Pool } = require('pg');

const pool = new Pool({ connectionString: process.env.DATABASE_URL });

const server = http.createServer(async (req, res) => {
  try {
    const { rows } = await pool.query('SELECT NOW()');
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ time: rows[0].now }));
  } catch (err) {
    console.error('DB Error:', err.message);
    res.writeHead(500);
    res.end('Internal Server Error');
  }
});

// ─── GRACEFUL SHUTDOWN ───
// Handle SIGTERM (from Kubernetes, Docker, process manager)
process.on('SIGTERM', async () => {
  console.log('🛑 SIGTERM received. Shutting down gracefully...');

  // 1. Stop accepting new connections
  server.close(() => {
    console.log('✅ HTTP server closed');
  });

  // 2. Close database connections
  await pool.end();
  console.log('✅ Database pool closed');

  // 3. Wait for pending requests (Event Loop will process them)
  // 4. Force exit after timeout (safety net)
  setTimeout(() => {
    console.error('⚠️ Forced shutdown after timeout');
    process.exit(1);
  }, 30000).unref();  // .unref() — Don't let this timer keep the process alive!
});

// Handle unhandled promise rejections
process.on('unhandledRejection', (reason) => {
  console.error('❌ Unhandled Rejection:', reason);
  // In Node 15+, this crashes the process. Always handle rejections!
});

server.listen(3000, () => {
  console.log('🚀 Server running on :3000');
});

// ❌ MISTAKE 1: Blocking the Event Loop in a request handler
app.get('/compute', (req, res) => {
  // ⛔ This blocks EVERYBODY for 5 seconds
  const end = Date.now() + 5000;
  while (Date.now() < end) {}
  res.send('Done');
});

// ✅ FIX: Use async or defer to Worker Thread
app.get('/compute', async (req, res) => {
  const result = await runInWorker(heavyComputation);
  res.send(result);
});

// ❌ MISTAKE 2: Confusing nextTick with setImmediate
process.nextTick(() => console.log('nextTick'));    // Runs BEFORE I/O
setImmediate(() => console.log('immediate'));       // Runs AFTER I/O
// Not the same! nextTick is NOT part of the Event Loop phases

// ❌ MISTAKE 3: Forgetting that Promises are microtasks
Promise.resolve().then(() => console.log('promise'));
// This runs BEFORE setTimeout(0) and setImmediate!

// ❌ MISTAKE 4: Not understanding process.exit behavior
const interval = setInterval(() => {
  console.log('tick');  // This may not run!
}, 100);
process.exit(0);  // ⛔ Exits immediately, interval never fires
// cleanup handlers still run (if any)

Output: 1, 2, 3, 4, 5

const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });

  // Bug 1: This blocks the entire server!
  const data = fs.readFileSync('big-file.txt');

  // Bug 2: setInterval never stops → memory leak
  const interval = setInterval(() => {
    res.write(new Date().toISOString() + '\n');
  }, 1000);

  // Bug 3: This never runs (res is already ended inside interval)
  res.end('Done');
});

server.listen(3000);

// ─── PHASE PRIORITY ────────────────────────────────
// 1. process.nextTick()    ← Microtask (highest)
// 2. Promise.then()        ← Microtask
// 3. setTimeout(fn, 0)     ← Timers Phase
// 4. setImmediate()        ← Check Phase

// ─── EXECUTION ORDER ───────────────────────────────
// Inside I/O: setImmediate > setTimeout(0)
// Outside I/O: depends on phase timing

// ─── EVENT LOOP LAG DETECTION ──────────────────────
const start = Date.now();
setImmediate(() => {
  const lag = Date.now() - start;
  console.log(`Event Loop Lag: ${lag}ms`);
});

// ─── THREAD POOL SIZE ──────────────────────────────
// UV_THREADPOOL_SIZE=8 node app.js
// Or: process.env.UV_THREADPOOL_SIZE = '8';

// ─── GRACEFUL SHUTDOWN ─────────────────────────────
process.on('SIGTERM', () => {
  server.close(() => process.exit(0));
});