𝗠𝗮𝘀𝘁𝗲𝗿 𝗚𝗼 𝗖𝗼𝗻𝗰𝘂𝗿𝗿𝗲𝗻𝗰𝘆 𝗪𝗶𝘁𝗵 𝗖𝗵𝗮𝗻𝗻𝗲𝗹𝘀
મેં એકવાર Go માં ઇમેજ પ્રોસેસિંગ પાઇપલાઇન બનાવી હતી.
મેં દરેક સ્ટેપ માટે goroutines નો ઉપયોગ કર્યો. મેં તેમને channels સાથે જોડ્યા. મેં રન (run) કર્યું.
પ્રોગ્રામ ફ્રીઝ થઈ ગયો. મેમરી વપરાશ વધ્યો. પછી તે બંધ થઈ ગયો. કોઈ એરર (errors) નહોતી. માત્ર શાંતિ હતી.
મેં બગડેલા શેડ્યુલરને ડિબગ કરવામાં કલાકો બગાડ્યા. હું ખોટો હતો. મને ખબર નહોતી કે channels કેવી રીતે કામ કરે છે.
તમારા Go પ્રોગ્રામ્સને હેંગ થતા રોકવા માટે અહીં ત્રણ નિયમો છે.
- Nil channels એ બ્લેક હોલ છે એક nil channel કાયમ માટે બ્લોક થઈ જાય છે. જો તમે nil channel પર ડેટા મોકલો અથવા મેળવો, તો goroutine અટકી જાય છે.
- હંમેશા તમારા channels ને
makeસાથે ઇનિશિયલાઇઝ કરો. - જો તમે અનિશ્ચિત હોવ તો nil ચેકનો ઉપયોગ કરો.
- ક્લોઝિંગના નિયમો પેનિક (panics) ને અટકાવે છે ચેનલ બંધ કરવી એ કાયમી છે.
- ફક્ત મોકલનાર (sender) એ જ ચેનલ બંધ કરવી જોઈએ.
- બંધ કરેલી ચેનલમાં ડેટા મોકલવાથી panic આવે છે.
- ચેનલ બંધ છે કે નહીં તે તપાસવા માટે બીજા રિટર્ન વેલ્યુનો ઉપયોગ કરો:
v, ok := <-ch. - જો
okfalse હોય, તો ચેનલ બંધ છે.
- સુરક્ષા માટે channel directions નો ઉપયોગ કરો Go તમને સ્પષ્ટ કરવાની મંજૂરી આપે છે કે ચેનલ મોકલવા માટે છે કે મેળવવા માટે.
chan<- intનો અર્થ છે કે તમે ફક્ત ડેટા મોકલી શકો છો.<-chan intનો અર્થ છે કે તમે ફક્ત ડેટા મેળવી શકો છો.- આ કમ્પાઈલરને તમારો કોડ રન કરતા પહેલા ભૂલો પકડવા માટે મજબૂર કરે છે.
ક્લીન પાઇપલાઇન કેવી રીતે બનાવવી:
- ચેનલ બરાબર એક જ વાર બંધ થાય તેની ખાતરી કરવા માટે
defer closeનો ઉપયોગ કરો. - channels પર લૂપ કરવા માટે
rangeનો ઉપયોગ કરો. જ્યારે ચેનલ બંધ થાય ત્યારે આ આપમેળે અટકી જાય છે. - કડક કરાર (strict contracts) બનાવવા માટે તમારા ફંક્શન્સને direction types અસાઇન કરો.
જ્યારે તમે આ પેટર્ન અનુસરો છો, ત્યારે તમે leaks અને panics ને અટકાવો છો. તમે એવા સિસ્ટમ્સ બનાવો છો જે ટેસ્ટ કરવામાં સરળ અને મજબૂત (robust) હોય છે.
તમારો પડકાર:
એક ફંક્શન લખો જે અનેક ઇનપુટ channels ને એક આઉટપુટ channel માં ભેગા કરે. select લૂપનો ઉપયોગ કરો. 500ms નો timeout ઉમેરો. ખાતરી કરો કે કોઈ goroutines leak ન થાય.
તમારો ઉકેલ કોમેન્ટ્સમાં પોસ્ટ કરો.