Arhitectura Node.js: de la JS la sistem

Înțelegerea arhitecturii Node.js nu este doar teorie academică, ci fundamentul oricărui dezvoltator care dorește să scrie aplicații scalabile și performante. Într-un mediu profesional, confuzia între operațiuni blocante și non-blocante duce rapid la degradarea experienței utilizatorului și la pierderea clienților. Cunoașterea modului în care motorul V8, evenimentele și bucla de evenimente interacționează îți permite să optimizezi resursele serverului și să eviți colapsul sub trafic ridicat. Practic, acest subiect transformă modul în care abordezi scrierea codului, trecând de la logica secvențială tradițională la una asincronă și eficientă.

Concepte cheie

• Motorul V8: Este motorul JavaScript open-source dezvoltat de Google, responsabil pentru compilarea codului JS în mașinărie nativă, oferind viteza și eficiența necesare runtime-ului Node.js.
• Event Loop (Bucla de evenimente): Mecanismul central care preia task-urile din coadă și le execută pe thread-ul principal, asigurând că aplicația rămâne non-blocantă chiar și în fața operațiilor I/O lente.
• Thread Pool (C++ API): Un set limitat de fire de execuție gestionate de libuv, folosit pentru operații I/O ale sistemului de fișiere, DNS și criptare, care nu pot fi delegate direct sistemului de operare în mod non-blocant.
• Stack-ul de apeluri (Call Stack): Structura LIFO care ține evidența funcțiilor care trebuie executate; când stiva este goală, Event Loop poate procesa următorul eveniment din coadă.
• Coada de Callback-uri: Locul unde așteaptă funcțiile de revenire (callback-uri) după ce operațiile asincrone s-au finalizat, înainte ca Event Loop să le poată programa pentru execuție.
• Microtasks vs Macrotasks: Microtask-urile (ex: Promise.then) au prioritate față de macrotask-urile (ex: setTimeout) și sunt executate imediat după ce stiva de apeluri se golește, înainte de următoarea iterație a event loop-ului.

Exemplu practic

Să analizăm un scenariu comun: citirea unui fișier și trimiterea unui răspuns HTTP.

const fs = require('fs');

app.get('/date', (req, res) => {
    // 1. Operație I/O asincronă (nu blochează thread-ul principal)
    fs.readFile('./data.json', 'utf8', (err, data) => {
        if (err) return res.status(500).send(err);
        
        // 2. Codul aici se execută doar după ce fișierul e citit
        res.json(JSON.parse(data));
    });

    // 3. Acest log apare IMEDIAT, nu așteaptă citirea fișierului
    console.log('Cerere primită'); 
});

În acest exemplu, fs.readFile este delegat thread pool-ului. Thread-ul principal continuă execuția, loghează mesajul și așteaptă următoarea cerere. Când fișierul este gata, callback-ul este pus în coadă. Event Loop îl va executa când stiva este liberă. Dacă am fi folosit readFileSync, thread-ul principal ar fi fost blocat până la final, oprint toate celelalte cereri.

Greșeli frecvente

• Blocarea Event Loop-ului: Executarea de calcule CPU intensive (ex: sortarea unui array uriaș) în thread-ul principal blochează procesarea tuturor celorlalte cereri. Soluția este folosirea worker_threads.
• Ignorarea erorilor în callback-uri: Lăsarea unui callback fără verificare pentru err duce la crash-uri silențioase sau comportamente nedefinite în producție.
• Confuzia între setImmediate și process.nextTick: nextTick se execută înainte de următoarea iterație a event loop-ului, iar excesul său poate bloca I/O-ul rețelei.

Întrebări de interviu

1. Ce se întâmplă dacă pui o operație CPU intensă în thread-ul principal? Răspuns: Event Loop se blochează. Nicio altă cerere HTTP, niciun timer și niciun callback I/O nu poate fi procesat până când operația nu se termină, ducând la timeout-uri pentru toți utilizatorii.

2. Care este diferența dintre Promise și Callback în contextul event loop-ului? Răspuns: Deși ambii sunt asincroni, promisiunile creează o coadă de microtask-uri cu prioritate mai mare decât macrotask-urile (callback-uri standard), garantând o ordine de execuție mai predictibilă și gestionarea erorilor mai curată.

3. Cum funcționează gestionarea memoriei în Node.js? Răspuns: Motorul V8 folosește un colectoare automat de gunoi (Garbage Collector) bazat pe generatii (New/Young și Old/Old). Obiectele noi sunt monitorizate frecvent, iar cele care supraviețuiesc mutării în generația veche sunt verificate mai rar, optimizând performanța.

Exercițiu

Creează un server simplu cu http module care simulează o operație lentă. Folosește setTimeout pentru a simula un delay de 2 secunde. În interiorul callback-ului, adaugă un buclă infinită simplă (while(true){}) sau un calcul matematic complex. Testează serverul cu două cereri simultane. Observă cum a doua cerere este blocată până când prima finalizează calculul. Refactorizează codul folosind async/await și asigură-te că înțelegi de ce blocarea apare totuși dacă nu externalizezi calculul.