उबंटू पर अपना पहला समवर्ती गो कार्यक्रम लिखना

Google की गो प्रोग्रामिंग भाषा 200 9 से आसपास रही है और 2012 में, भाषा अपनी आधिकारिक v1.0 स्थिति तक पहुंच गई। उन हस्तक्षेप वर्षों में, भाषा बदल दी गई है, इसमें बहुत कुछ बदल गया है। अपने बचपन में, कोई आधिकारिक द्विआधारी वितरण नहीं था और आपको या तो स्रोत कोड से जाना था, जो भाषा बदलती थी, या आपके लिनक्स वितरण के लिए प्री-बिल्ट पैकेज का उपयोग करने की अनुशंसित विधि थी। इसके बाद विंडोज़ समर्थन इंटेल के अलावा सीपीयू आर्किटेक्चर के लिए समर्थन के रूप में सीमित था।

तब से चीजें काफी सुधार हुई हैं। लिनक्स के लिए, गो इंस्टॉल करने के दो आसान तरीके हैं। गो डाउनलोड पेज से आधिकारिक लिनक्स बाइनरी बिल्ड डाउनलोड करें या अपने लिनक्स वितरण के लिए प्री-बिल्ट पैकेज का चयन करें। उबंटू पर गो इंस्टॉल करने का सबसे आसान तरीका apt-get का उपयोग apt-get :

 sudo apt-golang स्थापित करें 

एक बार गो इंस्टॉल हो जाने पर, आप प्रोग्राम विकसित करना शुरू कर सकते हैं। सबसे सरल गो कार्यक्रमों में से एक क्लासिक "हैलो वर्ल्ड!" कार्यक्रम है। एक टेक्स्ट एडिटर का उपयोग करके, निम्नलिखित शॉर्ट गो कोड के साथ " hellomte.go " नामक एक फ़ाइल बनाएं:

 पैकेज मुख्य आयात "एफएमटी" func मुख्य () {fmt.Println ("हैलो टेक आसान बनाएं!")} 

चूंकि v1.0 के जाने के बाद, व्यक्तिगत संकलन और लिंक कमांड की आवश्यकता को हटा दिया गया है और पुराने 8g और 8g 8l कमांड को कमांड के साथ बदल दिया गया है।

hellomte.go चलाने के लिए, एक टर्मिनल खोलें और उस फ़ोल्डर में निर्देशिका बदलें जिसमें स्रोत कोड फ़ाइल है, फिर टाइप करें:

 hellomte.go चलाओ जाओ 

यह गो प्रोग्राम को संकलित और चलाएगा लेकिन यह निष्पादन योग्य बाइनरी का उत्पादन नहीं करेगा। बाइनरी बनाने के लिए और फिर इसे चलाएं go build कमांड का उपयोग करें:

 hellomte.go ./hellomte निर्माण जाओ 

समेकन की शक्ति

गो प्रोग्रामिंग भाषा की परिभाषित विशेषताओं में से एक कॉन्सुरेंसी के लिए इसका समर्थन है जो एक कार्यक्रम को एक साथ कई कार्यों के साथ काम करने की अनुमति देता है। समांतरता, जो समरूपता के समान है, एक कार्यक्रम को एक साथ कई कार्यों को निष्पादित करने की अनुमति देता है, लेकिन समेकन एक कदम आगे जाता है जिसमें यह इन अलग-अलग कार्यों को संवाद करने और बातचीत करने की अनुमति देता है। नतीजतन, गो प्रोग्रामर को कार्यकर्ता पूल, पाइपलाइनों (जहां एक कार्य दूसरे के बाद होता है), और सिंक्रोनस या असिंक्रोनस पृष्ठभूमि कार्यों सहित विभिन्न समवर्ती डिज़ाइनों का उपयोग करने की अनुमति देता है। इस goroutine की नींव channels के साथ goroutine channels और गो का select कथन है।

यहां एक साधारण गो प्रोग्राम है जो एक समवर्ती गोरौटाइन का उपयोग करके कई बार स्ट्रिंग को प्रिंट करता है:

 पैकेज मुख्य आयात ("एफएमटी" "समय") func कहते हैं (एस स्ट्रिंग) {के लिए i: = 0; मैं <5; i ++ {fmt.Println (s)}} func main () {go say ("हैलो टेक को आसान बनाएं!") fmt.Println ("थोड़ा सो जाओ ...") समय। सो जाओ (100 * समय। मिलिसेकंद)} 

फ़ंक्शन say() स्ट्रिंग (पैरामीटर s ) को पांच बार प्रिंट करने के लिए बस एक साधारण पाश निष्पादित करता है। दिलचस्प बात यह है कि उस समारोह को कैसे कहा जाता है। सिर्फ कॉल करने के बजाय say("Hello Make Tech Easier!") कीवर्ड go फ़ंक्शन कॉल के सामने रखा जाता है। इसका मतलब है कि समारोह एक अलग कार्य के रूप में चलाया जाएगा। शेष main() फ़ंक्शन फिर goroutine को पूरा करने के लिए समय देने के लिए थोड़ा सा सोता है।

आउटपुट आपको आश्चर्यचकित कर सकता है:

जैसा कि आप देख सकते हैं कि say() फ़ंक्शन को goroutine रूप में चलाया जाता है और जब यह सेटअप किया जा रहा है, तो शेष main() फ़ंक्शन जारी रहता है, Sleep a little... सो रहा है Sleep a little... और फिर सोने जा रहा है। तब तक goroutine सक्रिय है और स्ट्रिंग को पांच बार प्रिंट करना शुरू कर देता है। अंततः कार्यक्रम समाप्त हो जाने के बाद कार्यक्रम समाप्त हो जाता है।

चैनल

goroutines चैनलों का उपयोग कर संवाद कर सकते हैं। एक चैनल एक गो कार्यक्रम के दो अलग-अलग हिस्सों के बीच संचार की एक पंक्ति खुलता है। आम तौर पर एक फ़ंक्शन को goroutine रूप में बुलाया जाएगा और यदि उसे डेटा वापस भेजने की आवश्यकता है (नेटवर्क ऑपरेशन से कहें) तो यह उस डेटा के साथ पास करने के लिए एक चैनल का उपयोग कर सकता है। यदि गो प्रोग्राम का एक और हिस्सा उस डेटा की प्रतीक्षा कर रहा है, तो डेटा तैयार होने तक यह सो जाएगा। चैनल make() फ़ंक्शन का उपयोग करके बनाए जाते हैं और उन्हें goroutines पैरामीटर के रूप में पारित किया जा सकता है।

इस कोड पर विचार करें:

 पैकेज मुख्य आयात ("एफएमटी") func कहते हैं (एस स्ट्रिंग, सी चैन int) {var i int i = 0; मैं <5; i ++ {fmt.Println (s)} c <- i} func main () {c: = make (chan int) कहें ("हैलो टेक को आसान बनाएं!", सी) एसटीएस: = <- c fmt.Println ( एसटीएस)} 

say() फ़ंक्शन अपवाद के साथ पहले उदाहरण के समान है कि दूसरा पैरामीटर एक चैनल है और स्ट्रिंग को प्रिंट करने के बाद, पुनरावृत्तियों की संख्या चैनल के c <- i लाइन के माध्यम से चैनल को भेज दी जाएगी।

मुख्य कार्य एक चैनल बनाता है, say() फ़ंक्शन को goroutine रूप में goroutine और उसके बाद डेटा goroutine करने के लिए डेटा को प्रतीक्षा करता है, goroutine sts := <- c परिणाम प्रिंट करने से पहले।

निष्कर्ष

पिछले कुछ सालों में गो भाषा में काफी प्रगति हुई है, अगर आपने हाल ही में इसे नहीं देखा है तो शायद अब एक अच्छा समय है!