Event loop உங்கள் JavaScript-ஐ ஒரே ஒரு thread-இல் இயக்குகிறது, எனவே நீண்ட நேரம் எடுக்கும் எந்த synchronous வேலையும் அதைத் தடுக்கிறது — தடுக்கப்பட்டிருக்கும் போது, Node வேறு எந்த request, timer அல்லது callback-ஐயும் சேவை செய்யாது. தடுப்பு எப்போதுமே கிட்டத்தட்ட CPU-bound வேலை அல்லது ஒரு *Sync API, சரியாக await செய்யப்பட்ட async I/O ஒருபோதும் அல்ல.
*Sync) API-கள் — fs.readFileSync, fs.writeFileSync, child_process.execSync, zlib.gzipSync. அவை libuv-க்கு ஒப்படைப்பதற்குப் பதிலாக இடத்திலேயே காத்திருக்கின்றன.map/sort/filter, matrix கணிதம், படம்/வீடியோ செயலாக்கம், மிகப்பெரிய structures-ஐ parsing/serializing செய்தல்.JSON.parse / JSON.stringify — synchronous மற்றும் O(n); பல-MB payload முழு parse-க்கும் loop-ஐ முடக்கிவிடும்.crypto.pbkdf2Sync, bcrypt sync mode, main thread-இல் பெரிய buffers-ஐ hashing செய்தல்.while (true), எல்லையற்ற recursion, ஒவ்வொரு உருப்படிக்கும் வேலை இருக்கும் மில்லியன் கணக்கான உருப்படிகள் மீது for.// இவை அனைத்தும் loop-ஐ தடுக்கின்றன — அந்த நேரத்தில் வேறு எந்த request-உம் சேவை செய்யப்படாது:
const data = fs.readFileSync("big.json"); // sync I/O
const obj = JSON.parse(hugeString); // பெரிய parse
const hash = crypto.pbkdf2Sync(pw, salt, 1e6, 64, "sha512"); // sync crypto
for (let i = 0; i < 1e9; i++) { /* CPU */ } // இறுக்கமான loop
CPU வேலையை ஒரு
asyncfunction-இல் மடிப்பது உதவாது —asyncawait-இல் மட்டுமே yield செய்கிறது; synchronous body இன்னும் loop thread-இல் முடிவடையும் வரை இயங்குகிறது.
perf_hooks.monitorEventLoopDelay() அல்லது blocked-at போன்ற libraries மூலம் அளவிடவும்; உயரும் lag என்பது ஏதோ ஒன்று thread-ஐ ஆக்கிரமித்திருப்பதைக் குறிக்கிறது.node --prof, clinic doctor/clinic flame, Chrome DevTools CPU profile.*Sync அழைப்பின் async எதிரணியைப் பயன்படுத்தவும் (fs.promises.readFile, crypto.pbkdf2, zlib.gzip).worker_threads pool, child process அல்லது வெளிப்புற queue/service-க்கு நகர்த்தவும்.setImmediate/await மூலம் chunk செய்யவும், இதனால் loop batches-க்கு இடையே மூச்சு விட முடியும்.const { Worker } = require("node:worker_threads");
// விலையுயர்ந்த hash-ஐ வெளியேற்றவும், இதனால் loop பதிலளிக்கக்கூடியதாக இருக்கும்.
const worker = new Worker("./hash-worker.js", { workerData: { pw, salt } });
Node-இல், ஒரு தடுக்கும் அழைப்பு அதை ஏற்படுத்திய request-ஐ மட்டுமல்ல, ஒவ்வொரு ஒரே நேரத்திலான client-ஐயும் தண்டிக்கிறது — latency உயரும், health checks timeout ஆகும், மற்றும் process சுமையின் கீழ் "தொங்கியது" போல தோன்றுகிறது. உறுதியான தடுப்பாளர்களை (*Sync, பெரிய JSON.parse, sync crypto, ReDoS, CPU loops) பெயரிட முடியுமா, event-loop lag கருவிகளால் அவற்றைக் கண்டறிய முடியுமா, மற்றும் async-க்கு மாறுவதன் மூலம் அல்லது worker threads-க்கு ஒப்படைப்பதன் மூலம் அவற்றைச் சரிசெய்ய முடியுமா என்பதைப் பார்க்க interviewers இதைக் கேட்கிறார்கள். இது production-இல் மிகவும் பொதுவான ஒற்றை Node performance தோல்வி.
விரிவான பதில்களுடன் கூடிய IT நேர்காணல் கேள்விகளின் நூலகம் — Junior முதல் Senior வரை.
நன்கொடை