Node.js Event Loop விளக்கம்
Node.js ஒரு ஒற்றை த்ரெட்டைப் (single thread) பயன்படுத்துகிறது. ஒரே நேரத்தில் ஆயிரக்கணக்கான கோரிக்கைகளை (requests) அது எப்படி கையாள்கிறது என்று நீங்கள் வியக்கலாம்.
இதற்குக் காரணம் Event Loop ஆகும்.
ஒரு பணி முடிவடைவதற்காகக் காத்திருக்காமல், Node.js அதிக நேரம் எடுக்கும் பணிகளை இயங்குதளத்திற்கு (operating system) அனுப்பிவிடுகிறது. இது அடுத்த பணிக்குத் தொடர்ந்து நகர்ந்து கொண்டே இருக்கும். இது உங்கள் செயலிகளை வேகமாகவும், துரிதமாகவும் (responsive) மாற்றுகிறது.
Blocking vs Non-blocking
நீங்கள் readFileSync போன்ற sync செயல்பாடுகளைப் பயன்படுத்தினால், சர்வர் நின்றுவிடும். கோப்பு வாசிப்பு முடியும் வரை அது காத்திருக்கும். மற்ற பயனர்களுக்கு எந்தப் பதிலும் கிடைக்காது. இது உங்கள் செயல்திறனை (performance) பாதிக்கும்.
நீங்கள் fs.readFile பயன்படுத்தினால், சர்வர் தொடர்ந்து இயங்கும். பின்னணியில் (background) கோப்பு வாசிக்கப்படும் போது, அது மற்ற கோரிக்கைகளைக் கையாளும்.
Event Loop எவ்வாறு செயல்படுகிறது
இந்த லூப் பல நிலைகளைக் கடந்து செல்கிறது:
• Timers: setTimeout மற்றும் setInterval-ஐக் கையாள்கிறது.
• Pending Callbacks: கணினி நிலை பிழைகளைக் (system level errors) கையாள்கிறது.
• Poll: புதிய இணைப்புகளைப் பெற்று, தரவுத்தள வினவல்களை (database queries) போன்ற I/O பணிகளைக் கையாள்கிறது.
• Check: setImmediate-ஐக் கையாள்கிறது.
• Close Callbacks: சாக்கெட் மூடுதல்களை (socket closures) கையாள்கிறது.
முன்னுரிமை வரிசை (The Priority Order)
எல்லாப் பணிகளும் சமமானவை அல்ல. Node.js இரண்டு வரிசைகளை (queues) பயன்படுத்துகிறது:
- Microtask Queue: இது Promises-களைக் கொண்டிருக்கும்.
- Callback Queue: இது
setTimeoutமற்றும் I/O-வைச் கொண்டிருக்கும்.
Microtask Queue எப்போதும் முதலில் இயங்கும். உங்களிடம் ஒரு Promise மற்றும் ஒரு setTimeout இருந்தால், டைமருக்கு முன்பே Promise முடிந்துவிடும்.
Call Stack மற்றும் Queues
Call Stack தற்போது எந்தக் குறியீடு (code) இயங்குகிறது என்பதைக் கண்காணிக்கிறது. ஒரு பணி முடிந்ததும், அதன் callback ஒரு வரிசையில் (queue) சேரும். Call Stack காலியாகும் வரை காத்திருந்துவிட்டு, அதன் பின்னரே Event Loop வரிசையிலிருந்து பணிகளை எடுக்கும்.
இந்தத் தவறுகளைத் தவிர்க்கவும்:
• முடிவில்லா லூப்களை (infinite loops) பயன்படுத்த வேண்டாம். இது உங்கள் முழு செயலியையும் முடக்கிவிடும். • தயாரிப்புச் சூழலில் (production) synchronous file முறைகளைப் பயன்படுத்த வேண்டாம். • மெயின் த்ரெட்டில் (main thread) கடினமான கணித அல்லது வீடியோ செயலாக்கங்களைச் செய்ய வேண்டாம்.
கடினமான பணிகளுக்கு, Worker Threads அல்லது பின்னணிப் பணிகளைப் (background jobs) பயன்படுத்தவும்.
சுருக்கம் (Summary)
Node.js காத்திருக்காததால் இது வேகமானது. இது I/O பணிகளைப் பிறருக்குப் பகிர்ந்து அளித்து, முடிவுகளை நிர்வகிக்க Event Loop-ஐப் பயன்படுத்துகிறது. இந்த கட்டமைப்பு (architecture) ஒரு த்ரெட் மூலம் பல பயனர்களுக்குச் சேவை செய்ய அனுமதிக்கிறது.
Event Loop-இல் எந்தப் பகுதி உங்களுக்குக் கற்றுக்கொள்ளக் கடினமாக இருந்தது? கருத்துப் பெட்டியில் (comments) என்னிடம் சொல்லுங்கள்.