𝗠𝗮𝘀𝘁𝗲𝗿 𝗚𝗼 𝗖𝗼𝗻𝗰𝘂𝗿𝗿𝗲𝗻𝗰𝘆 𝗪𝗶𝘁𝗵 𝗖𝗵𝗮𝗻𝗻𝗲𝗹𝘀

ਚੈਨਲਾਂ (Channels) ਨਾਲ Go Concurrency ਵਿੱਚ ਮਾਹਰ ਬਣੋ

ਮੈਂ ਇੱਕ ਵਾਰ Go ਵਿੱਚ ਇੱਕ image processing pipeline ਬਣਾਈ ਸੀ।

ਮੈਂ ਹਰ ਕਦਮ ਲਈ goroutines ਦੀ ਵਰਤੋਂ ਕੀਤੀ। ਮੈਂ ਉਹਨਾਂ ਨੂੰ channels ਨਾਲ ਜੋੜਿਆ। ਮੈਂ run ਕੀਤਾ।

ਪ੍ਰੋਗਰਾਮ ਫ੍ਰੀਜ਼ ਹੋ ਗਿਆ। Memory usage ਵਧਦੀ ਗਈ। ਫਿਰ ਇਹ ਬੰਦ ਹੋ ਗਿਆ। ਕੋਈ error ਨਹੀਂ ਸੀ। ਸਿਰਫ਼ ਚੁੱਪ ਸੀ।

ਮੈਂ ਇੱਕ ਖਰਾਬ scheduler ਨੂੰ debug ਕਰਨ ਵਿੱਚ ਕਈ ਘੰਟੇ ਬਰਬਾਦ ਕੀਤੇ। ਮੈਂ ਗਲਤ ਸੀ। ਮੈਨੂੰ ਸਮਝ ਨਹੀਂ ਆ ਰਿਹਾ ਸੀ ਕਿ channels ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ।

ਤੁਹਾਡੇ Go ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਹੈਂਗ ਹੋਣ ਤੋਂ ਰੋਕਣ ਲਈ ਇੱਥੇ ਤਿੰਨ ਨਿਯਮ ਹਨ।

1. Nil channels ਬਲੈਕ ਹੋਲ (black holes) ਹਨ ਇੱਕ nil channel ਹਮੇਸ਼ਾ ਲਈ ਬਲਾਕ ਕਰ ਦਿੰਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ nil channel 'ਤੇ ਕੁਝ ਭੇਜਦੇ ਜਾਂ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹੋ, ਤਾਂ goroutine ਉੱਥੇ ਹੀ ਫਸ ਜਾਂਦੀ ਹੈ।

• ਹਮੇਸ਼ਾ ਆਪਣੇ channels ਨੂੰ make ਨਾਲ initialize ਕਰੋ।
• ਜੇਕਰ ਤੁਸੀਂ ਅਨਿਸ਼ਚਿਤ ਹੋ ਤਾਂ nil check ਦੀ ਵਰਤੋਂ ਕਰੋ।

2. Closing ਦੇ ਨਿਯਮ panics ਨੂੰ ਰੋਕਦੇ ਹਨ ਇੱਕ channel ਨੂੰ ਬੰਦ ਕਰਨਾ ਸਥਾਈ (permanent) ਹੁੰਦਾ ਹੈ।

• ਸਿਰਫ਼ ਭੇਜਣ ਵਾਲੇ (sender) ਨੂੰ ਹੀ channel ਬੰਦ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
• ਇੱਕ ਬੰਦ channel 'ਤੇ ਡਾਟਾ ਭੇਜਣ ਨਾਲ panic ਹੁੰਦਾ ਹੈ।
• ਇਹ ਚੈੱਕ ਕਰਨ ਲਈ ਕਿ ਕੀ channel ਬੰਦ ਹੈ, ਦੂਜੀ return value ਦੀ ਵਰਤੋਂ ਕਰੋ: v, ok := <-ch।
• ਜੇਕਰ ok false ਹੈ, ਤਾਂ channel ਬੰਦ ਹੈ।

3. ਸੁਰੱਖਿਆ ਲਈ channel directions ਦੀ ਵਰਤੋਂ ਕਰੋ Go ਤੁਹਾਨੂੰ ਦੱਸਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਕਿ channel ਭੇਜਣ ਲਈ ਹੈ ਜਾਂ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ।

• chan<- int ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਸਿਰਫ਼ ਡਾਟਾ ਭੇਜ ਸਕਦੇ ਹੋ।
• <-chan int ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਸਿਰਫ਼ ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ।
• ਇਹ compiler ਨੂੰ ਤੁਹਾਡਾ ਕੋਡ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਗਲਤੀਆਂ ਫੜਨ ਲਈ ਮਜਬੂਰ ਕਰਦਾ ਹੈ।

ਇੱਕ ਸਾਫ਼ (clean) pipeline ਕਿਵੇਂ ਬਣਾਈ ਜਾਵੇ:

• ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ channel ਸਿਰਫ਼ ਇੱਕ ਵਾਰ ਬੰਦ ਹੋਵੇ, defer close ਦੀ ਵਰਤੋਂ ਕਰੋ।
• channels 'ਤੇ loop ਚਲਾਉਣ ਲਈ range ਦੀ ਵਰਤੋਂ ਕਰੋ। ਜਦੋਂ channel ਬੰਦ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਹ ਆਪਣੇ ਆਪ ਰੁਕ ਜਾਂਦਾ ਹੈ।
• ਸਖ਼ਤ ਕੰਟਰੈਕਟ (strict contracts) ਬਣਾਉਣ ਲਈ ਆਪਣੇ functions ਨੂੰ direction types ਅਸਾਈਨ ਕਰੋ।

ਜਦੋਂ ਤੁਸੀਂ ਇਹਨਾਂ ਪੈਟਰਨਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ leaks ਅਤੇ panics ਨੂੰ ਰੋਕਦੇ ਹੋ। ਤੁਸੀਂ ਅਜਿਹੇ ਸਿਸਟਮ ਬਣਾਉਂਦੇ ਹੋ ਜੋ ਟੈਸਟ ਕਰਨ ਵਿੱਚ ਆਸਾਨ ਅਤੇ ਮਜ਼ਬੂਤ (robust) ਹੁੰਦੇ ਹਨ।

ਤੁਹਾਡੀ ਚੁਣੌਤੀ: ਇੱਕ ਅਜਿਹਾ function ਲਿਖੋ ਜੋ ਕਈ input channels ਨੂੰ ਇੱਕ output channel ਵਿੱਚ ਮਿਲਾ (merge) ਦੇਵੇ। ਇੱਕ select loop ਦੀ ਵਰਤੋਂ ਕਰੋ। 500ms ਦਾ timeout ਜੋੜੋ। ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਕੋਈ ਵੀ goroutine leak ਨਾ ਹੋਵੇ।

ਆਪਣਾ ਹੱਲ comment ਵਿੱਚ ਪੋਸਟ ਕਰੋ।

ਸਰੋਤ: https://dev.to/timevolt/go-concurrency-the-jedis-guide-to-goroutines-channels-may-the-fork-be-with-you-2g79