𝗡𝗼𝗱𝗲.𝗷𝘀 𝗘𝘃𝗲𝗻𝘁 𝗟𝗼𝗼𝗽 ਦੀ ਵਿਆਖਿਆ
Node.js ਇੱਕ ਸਿੰਗਲ ਥ੍ਰੈਡ (single thread) ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ ਸ਼ਾਇਦ ਸੋਚਦੇ ਹੋਵੋਗੇ ਕਿ ਇਹ ਇੱਕੋ ਸਮੇਂ ਹਜ਼ਾਰਾਂ ਰਿਕਵੈਸਟਾਂ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਦਾ ਹੈ।
ਇਸ ਦਾ ਰਾਜ਼ Event Loop ਹੈ।
ਕਿਸੇ ਕੰਮ ਦੇ ਖਤਮ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰਨ ਦੀ ਬਜਾਏ, Node.js ਸਮਾਂ ਲੈਣ ਵਾਲੇ ਕੰਮਾਂ ਨੂੰ ਆਪਰੇਟਿੰਗ ਸਿਸਟਮ ਕੋਲ ਭੇਜ ਦਿੰਦਾ ਹੈ। ਇਹ ਅਗਲੇ ਕੰਮ ਵੱਲ ਵਧਦਾ ਰਹਿੰਦਾ ਹੈ। ਇਹ ਤੁਹਾਡੀਆਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਤੇਜ਼ ਅਤੇ ਰਿਸਪੌਂਸਿਵ (responsive) ਬਣਾਉਂਦਾ ਹੈ।
Blocking ਬਨਾਮ Non-blocking
ਜੇਕਰ ਤੁਸੀਂ readFileSync ਵਰਗੇ sync ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਸਰਵਰ ਰੁਕ ਜਾਂਦਾ ਹੈ। ਇਹ ਫਾਈਲ ਪੜ੍ਹਨ ਦੇ ਖਤਮ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ। ਕਿਸੇ ਹੋਰ ਯੂਜ਼ਰ ਨੂੰ ਕੋਈ ਜਵਾਬ (response) ਨਹੀਂ ਮਿਲਦਾ। ਇਹ ਤੁਹਾਡੀ ਪਰਫਾਰਮੈਂਸ ਨੂੰ ਖਰਾਬ ਕਰ ਦਿੰਦਾ ਹੈ।
ਜੇਕਰ ਤੁਸੀਂ fs.readFile ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਸਰਵਰ ਚੱਲਦਾ ਰਹਿੰਦਾ ਹੈ। ਜਦੋਂ ਫਾਈਲ ਬੈਕਗ੍ਰਾਊਂਡ ਵਿੱਚ ਪੜ੍ਹੀ ਜਾ ਰਹੀ ਹੁੰਦੀ ਹੈ, ਇਹ ਹੋਰ ਰਿਕਵੈਸਟਾਂ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ।
Event Loop ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ
ਲੂਪ ਕਈ ਪੜਾਵਾਂ ਵਿੱਚੋਂ ਲੰਘਦਾ ਹੈ:
• Timers: setTimeout ਅਤੇ setInterval ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ।
• Pending Callbacks: ਸਿਸਟਮ ਪੱਧਰ ਦੀਆਂ ਗਲਤੀਆਂ (errors) ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ।
• Poll: ਨਵੇਂ ਕਨੈਕਸ਼ਨ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਡਾਟਾਬੇਸ ਕੁਏਰੀਆਂ ਵਰਗੇ 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 ਇਸ ਗੱਲ ਦਾ ਧਿਆਨ ਰੱਖਦਾ ਹੈ ਕਿ ਇਸ ਸਮੇਂ ਕਿਹੜਾ ਕੋਡ ਚੱਲ ਰਿਹਾ ਹੈ। ਜਦੋਂ ਕੋਈ ਕੰਮ ਖਤਮ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਉਸਦਾ ਕਾਲਬੈਕ (callback) ਇੱਕ ਕਿਊ ਵਿੱਚ ਚਲਾ ਜਾਂਦਾ ਹੈ। Event Loop ਕਿਊ ਵਿੱਚੋਂ ਕੰਮ ਕੱਢਣ ਤੋਂ ਪਹਿਲਾਂ ਉਦੋਂ ਤੱਕ ਉਡੀਕ ਕਰਦਾ ਹੈ ਜਦੋਂ ਤੱਕ Call Stack ਖਾਲੀ ਨਹੀਂ ਹੋ ਜਾਂਦਾ।
ਇਹਨਾਂ ਗਲਤੀਆਂ ਤੋਂ ਬਚੋ:
• ਇਨਫੀਨੀਟ ਲੂਪਸ (infinite loops) ਦੀ ਵਰਤੋਂ ਨਾ ਕਰੋ। ਇਹ ਤੁਹਾਡੀ ਪੂਰੀ ਐਪ ਨੂੰ ਫ੍ਰੀਜ਼ ਕਰ ਦਿੰਦਾ ਹੈ। • ਪ੍ਰੋਡਕਸ਼ਨ (production) ਵਿੱਚ ਸਿੰਕਰੋਨਸ ਫਾਈਲ ਮੈਥਡਸ ਦੀ ਵਰਤੋਂ ਨਾ ਕਰੋ। • ਮੇਨ ਥ੍ਰੈਡ (main thread) 'ਤੇ ਭਾਰੀ ਗਣਨਾ (math) ਜਾਂ ਵੀਡੀਓ ਪ੍ਰੋਸੈਸਿੰਗ ਨਾ ਚਲਾਓ।
ਭਾਰੀ ਕੰਮਾਂ ਲਈ, Worker Threads ਜਾਂ ਬੈਕਗ੍ਰਾਊਂਡ ਜੌਬਸ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਸਾਰ (Summary)
Node.js ਤੇਜ਼ ਹੈ ਕਿਉਂਕਿ ਇਹ ਉਡੀਕ ਨਹੀਂ ਕਰਦਾ। ਇਹ I/O ਕੰਮਾਂ ਨੂੰ ਡੈਲੀਗੇਟ (delegate) ਕਰਦਾ ਹੈ ਅਤੇ ਨਤੀਜਿਆਂ ਨੂੰ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਲਈ Event Loop ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਇਹ ਆਰਕੀਟੈਕਚਰ ਇੱਕ ਥ੍ਰੈਡ ਨੂੰ ਬਹੁਤ ਸਾਰੇ ਯੂਜ਼ਰਾਂ ਦੀ ਸੇਵਾ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।
Event Loop ਦਾ ਕਿਹੜਾ ਹਿੱਸਾ ਤੁਹਾਡੇ ਲਈ ਸਿੱਖਣਾ ਸਭ ਤੋਂ ਔਖਾ ਸੀ? ਮੈਨੂੰ ਕੁਮੈਂਟਸ ਵਿੱਚ ਦੱਸੋ।