रूबी में धागे का उपयोग करना

कई रूबी डेवलपर्स धागे की उपेक्षा करते हैं, हालांकि यह एक बहुत ही उपयोगी उपकरण है। इस लेख में, हम रूबी में आईओ प्रवाह के निर्माण पर विचार करेंगे और यह दिखाएंगे कि रूबी कैसे प्रवाह के साथ मुकाबला करती है जिसमें कई कम्प्यूटेशनल ऑपरेशन होते हैं। आइए वैकल्पिक रूबी कार्यान्वयन लागू करने का प्रयास करें, और यह भी पता करें कि DRb मॉड्यूल का उपयोग करके क्या परिणाम प्राप्त किए जा सकते हैं। लेख के अंत में, हम देखेंगे कि इन सिद्धांतों का उपयोग रूबी अनुप्रयोगों के लिए रूबी के लिए विभिन्न सर्वरों में कैसे किया जाता है।

IO रूबी में बहती है

एक छोटे से उदाहरण पर विचार करें:

def call_remote(host) sleep 3 #      end 

यदि हमें दो सर्वरों का उपयोग करने की आवश्यकता है, उदाहरण के लिए, कैश को साफ़ करने के लिए, और हम इस फ़ंक्शन को दो बार उत्तराधिकार में कॉल करेंगे:

 call_remote 'host1/clear_caches' call_remote 'host2/clear_caches' 

तब हमारा कार्यक्रम 6 सेकंड के लिए काम करेगा।

यदि हम थ्रेड्स का उपयोग करते हैं, तो हम प्रोग्राम निष्पादन को गति दे सकते हैं, जैसे:

 threads = [] ['host1', 'host2'].each do |host| threads << Thread.new do call_remote "#{host}/clear_caches" end end threads.each(&:join) 

हमने दो थ्रेड बनाए, प्रत्येक थ्रेड में हमने अपने सर्वर की ओर रुख किया और # जॉइन कमांड्स ने कहा कि मुख्य प्रोग्राम (मुख्य थ्रेड) को उनके खत्म होने का इंतजार करना चाहिए। अब हमारा कार्यक्रम 3 सेकंड में तेजी से दो बार सफलतापूर्वक चलता है।

अच्छी और अलग की अधिक धाराएँ

एक अधिक जटिल उदाहरण पर विचार करें, जिसमें हम दिए गए एपीआई के माध्यम से जेकिल परियोजना के बारे में गिटहब के साथ सभी बंद बग और समस्याओं को प्राप्त करने का प्रयास करेंगे।

चूंकि हम GitHub पर DoS अटैक करना नहीं चाहते हैं, इसलिए हमें एक साथ थ्रेड की संख्या को सीमित करने, उन्हें प्लान करने, उन्हें लॉन्च करने और उपलब्ध होने के साथ परिणाम एकत्र करने की आवश्यकता है।

मानक रूबी पुस्तकालय ऐसी समस्याओं को हल करने के लिए तैयार उपकरण प्रदान नहीं करता है, इसलिए मैंने रूबी में थ्रेड समूह बनाने के लिए अपने खुद के FutureProof पुस्तकालय को लागू किया, जिसका उपयोग करने के बारे में मैं अधिक बात करना चाहता हूं।

इसका सिद्धांत सरल है - आपको एक नया समूह बनाने की आवश्यकता है, जो एक साथ सूत्र की अधिकतम स्वीकार्य संख्या को निर्दिष्ट करता है:

 thread_pool = FutureProof::ThreadPool.new(5) 

इसमें कार्य जोड़ें:

 thread_pool.submit 2, 5 do |a, b| a + b end 

और उनका अर्थ पूछें:

 thread_pool.values 

इस प्रकार, जेकेल परियोजना के बारे में हमें जो जानकारी चाहिए, उसे प्राप्त करने के लिए, निम्नलिखित कोड पर्याप्त होगा:

 require 'future_proof' require 'net/http' thread_pool = FutureProof::ThreadPool.new(5) 10.times do |i| thread_pool.submit i do |page| uri = URI.parse( "https://api.github.com/repos/mojombo/jekyll/issues?state=close&page=#{page + 1}&per_page=100.json" ) http = Net::HTTP.new(uri.host, uri.port) http.use_ssl = true http.request(Net::HTTP::Get.new(uri.request_uri)).body end end thread_pool.perform puts thread_pool.values[3] # [{"url":"https://api.github.com/repo ... 

FutureProof लाइब्रेरी का कार्यान्वयन कतार वर्ग पर आधारित है, जो कई धागों के साथ काम करने के लिए सुरक्षित कतार बनाने की अनुमति देता है, यह सुनिश्चित करता है कि एकाधिक धागे एक-दूसरे के ऊपर एक साथ कतार में मान नहीं लिखते हैं, और एक ही समय में एक ही मूल्य पर विचार नहीं करते हैं।

लाइब्रेरी ने अपवाद हैंडलिंग को भी विकसित किया है - यदि थ्रेड निष्पादन के दौरान ऐसा हुआ, तो थ्रेड_पुल अभी भी प्राप्त मूल्यों से एक सरणी वापस करने में सक्षम होगा और केवल एक अपवाद फेंक देगा यदि प्रोग्रामर सीधे सरणी के एक विशिष्ट तत्व तक पहुंचने का प्रयास करता है।

थ्रेड समूहों का कार्यान्वयन रूबी की जावा और java.util.concurrent के करीब धागे के साथ काम करने की क्षमता लाने का एक प्रयास है, जो आंशिक रूप से प्रेरित था।

FutureProof लाइब्रेरी का उपयोग करके, आप IO धाराओं के साथ काम करने से जुड़े कार्यों को और अधिक आसानी से और कुशलता से कर सकते हैं। पुस्तकालय रूबी संस्करण 1.9.3, 2.0, साथ ही रुबिनस का समर्थन करता है।

थ्रेड्स और कम्प्यूटिंग

थ्रेड्स का उपयोग करके कार्यक्रम के प्रदर्शन को बेहतर बनाने के सफल अनुभव को ध्यान में रखते हुए, हम दो परीक्षण करेंगे, जिनमें से एक में हम उत्तराधिकार में दो बार में 1000 और दूसरी बार समानांतर में गणना करेंगे।

 require 'benchmark' factorial = Proc.new { |n| 1.upto(n).inject(1) { |i, n| i * n } } Benchmark.bm do |x| x.report('sequential') do 10_000.times do 2.times do factorial.call 1000 end end end x.report('thready') do 10_000.times do threads = [] 2.times do threads << Thread.new do factorial.call 1000 end end threads.each &:join end end end 

परिणामस्वरूप, हमें एक अप्रत्याशित परिणाम मिला ( रूबी 2.0 का उपयोग करके) - समानांतर निष्पादन में एक दूसरा समय लगा:

  user system total real sequential 24.130000 1.510000 25.640000 (25.696196) thready 24.600000 2.420000 27.020000 (26.877708) 

एक कारण यह है कि हम कोड को शेड्यूलिंग थ्रेड्स के साथ जटिल करते हैं, और दूसरा, रूबी, एक समय में इस कार्यक्रम को निष्पादित करने के लिए केवल एक कोर का उपयोग करता है। दुर्भाग्य से, रूबी को एक माणिक प्रक्रिया के लिए कई कोर का उपयोग करने के लिए मजबूर करने का अवसर वर्तमान में प्रदान नहीं किया गया है।

चलिए मैं आपको उसी स्क्रिप्ट को निष्पादित करने का परिणाम दिखाता हूं।

  user system total real sequential 33.180000 0.690000 33.870000 (33.090000) thready 37.820000 3.830000 41.650000 (24.333000) 

जैसा कि आप देख सकते हैं, परिणाम बेहतर हो गया है। क्योंकि माप दो कोर के साथ एक कंप्यूटर पर हुआ, और कोर में से एक का उपयोग केवल 75% द्वारा किया गया था, सुधार 200% नहीं था। लेकिन, इसलिए, बड़ी संख्या में कोर के साथ एक कंप्यूटर पर, हम और भी अधिक समानांतर धागे कर सकते हैं और हमारे परिणाम में और सुधार कर सकते हैं।

jRuby JVM पर रूबी का एक वैकल्पिक कार्यान्वयन है, जो भाषा में बहुत ही शानदार विशेषताओं को लाता है।

एक साथ थ्रेड्स की संख्या चुनते समय, यह याद रखना आवश्यक है कि प्रदर्शन के नुकसान के बिना हम एक कोर पर IO संचालन में लगे बहुत सारे थ्रेड्स की व्यवस्था कर सकते हैं। लेकिन हम प्रदर्शन में थोड़ा कम हो जाएंगे यदि कम्प्यूटेशनल ऑपरेशन के मामले में थ्रेड्स की संख्या कोर की संख्या से अधिक हो जाती है।

मूल रूबी कार्यान्वयन ( एमआरआई ) के मामले में, कम्प्यूटेशनल संचालन के लिए केवल एक धागे का उपयोग करने की सिफारिश की जाती है। थ्रेड्स के साथ सही समानता केवल रबी और रूबिनियस का उपयोग करके प्राप्त की जा सकती है।

प्रक्रिया स्तर संगामिति

जैसा कि अब हम जानते हैं, रूबी एमआरआई एक रूबी प्रक्रिया के लिए ( यूनिक्स सिस्टम पर) एक समय में केवल एक कोर के संसाधनों का उपयोग कर सकता है। इस कमी को पूरा करने के तरीकों में से एक है, प्रक्रियाओं के कांटे का उपयोग करना, उदाहरण के लिए इस तरह:

 read, write = IO.pipe result = 5 pid = fork do result = result + 5 Marshal.dump(result, write) exit 0 end write.close result = read.read Process.wait(pid) puts Marshal.load(result) 

प्रक्रिया का कांटा, निर्माण के समय, परिणाम चर के मान को 5 के बराबर कॉपी करता है, लेकिन मुख्य प्रक्रिया में कांटा के अंदर चर के आगे परिवर्तन नहीं दिखता है, इसलिए हमें कांटा और IO.pipe के बीच मुख्य प्रक्रिया के बीच एक संदेश स्थापित करने की आवश्यकता है।

यह विधि प्रभावी है, बल्कि बोझिल और असुविधाजनक है। वितरण प्रोग्रामिंग के लिए DRb मॉड्यूल का उपयोग करके, आप अधिक रोचक परिणाम प्राप्त कर सकते हैं।

हम प्रक्रिया तुल्यकालन के लिए DRb मॉड्यूल का उपयोग करते हैं

DRb मॉड्यूल मानक रूबी लाइब्रेरी का हिस्सा है और वितरण प्रोग्रामिंग क्षमताओं के लिए जिम्मेदार है। उनके विचार का आधार नेटवर्क पर किसी भी कंप्यूटर पर एक रूबी ऑब्जेक्ट को एक्सेस देने की क्षमता है। इस ऑब्जेक्ट के साथ सभी जोड़तोड़ के परिणाम, इसकी आंतरिक स्थिति, सभी जुड़े कंप्यूटरों को दिखाई देती है, और लगातार सिंक्रनाइज़ होती है। सामान्य तौर पर, मॉड्यूल सुविधाएँ बहुत विस्तृत होती हैं, और एक अलग लेख के योग्य होती हैं।

मैं Rinda :: TupleSpace tuples के साथ मिलकर इस DRb फीचर के साथ मुख्य प्रोग्राम कंप्यूटर और अन्य कनेक्टेड मशीनों पर अलग-अलग प्रक्रियाओं में कोड निष्पादित करने के लिए जिम्मेदार Pthread मॉड्यूल बनाने के विचार के साथ आया था। Rinda :: TupleSpace नाम से tuples तक पहुँच प्रदान करता है और, Queue ऑब्जेक्ट्स की तरह, वे आपको एक समय में केवल एक थ्रेड या प्रक्रिया के लिए tuples लिखने और पढ़ने की अनुमति देते हैं।

इस प्रकार, एक समाधान दिखाई दिया जो रूबी एमआरआई को कई कोर पर कोड निष्पादित करने की अनुमति देता है:

 Pthread::Pthread.new queue: 'fact', code: %{ 1.upto(n).inject(1) { |i, n| i * n } }, context: { n: 1000 } 

जैसा कि आपने देखा होगा कि कोड को निष्पादित करने की आवश्यकता होती है, क्योंकि इसे स्ट्रिंग के रूप में परोसा जाता है प्रक्रियाओं के मामले में, डीआरबी केवल एक लिंक के लिए दूसरी प्रक्रिया में स्थानांतरित होता है, और इसके निष्पादन के लिए इस प्रक्रिया को बनाने वाले संसाधनों का उपयोग करता है। मुख्य प्रक्रिया के संदर्भ से छुटकारा पाने के लिए, मैं एक स्ट्रिंग के रूप में अन्य प्रक्रियाओं को कोड सबमिट करता हूं, और एक अतिरिक्त शब्दकोश में स्ट्रिंग चर के मूल्यों को। कोड निष्पादन के लिए अतिरिक्त मशीनों को कैसे कनेक्ट किया जाए, इसका एक उदाहरण प्रोजेक्ट होम पेज पर पाया जा सकता है।

Preadread पुस्तकालय MRI संस्करणों 1.9.3 और 2.0 का समर्थन करता है।

रूबी ऑन रेल्स में कंसीडर

पृष्ठभूमि कार्यों के प्रदर्शन के लिए रेल और पुस्तकालयों पर रूबी के लिए सर्वर को दो समूहों में विभाजित किया जा सकता है। उपयोगकर्ता के अनुरोधों को संसाधित करने या पृष्ठभूमि के कार्यों को करने के लिए पहला उपयोग कांटे करता है - अतिरिक्त प्रक्रियाएं। इस प्रकार, एमआरआई और इन सर्वरों और पुस्तकालयों का उपयोग करके, हम एक साथ कई अनुरोधों को संसाधित कर सकते हैं, और एक साथ कई कार्य कर सकते हैं।

हालाँकि, इस पद्धति में एक खामी है। प्रक्रियाओं के कांटे उस प्रक्रिया की मेमोरी को कॉपी करते हैं जो उन्हें बनाया था, और इसलिए तीन "श्रमिकों" के साथ एक यूनिकॉर्न सर्वर 1GB मेमोरी ले सकता है, बमुश्किल शुरू होने वाला काम। वही पृष्ठभूमि कार्यों के लिए पुस्तकालयों के लिए जाता है, जैसे कि रेस्क ।

पटरियों पर रूबी के लिए प्यूमा सर्वर के रचनाकारों ने रूबी और रुबिनियस की विशेषताओं को ध्यान में रखा , और इन दो कार्यान्वयन पर मुख्य रूप से केंद्रित एक सर्वर जारी किया। उसी यूनिकॉर्न के विपरीत, प्यूमा उन थ्रेड्स का उपयोग करता है जिन्हें एक साथ अनुरोधों को संसाधित करने के लिए बहुत कम मेमोरी की आवश्यकता होती है। इस प्रकार, जुमा या रूबिनस के साथ संयोजन में उपयोग किए जाने पर प्यूमा एक बढ़िया विकल्प होगा। इसलिए, साइडकीक पुस्तकालय सिद्धांत रूप में तीन गुना है ।

निष्कर्ष

थ्रेड्स एक बहुत शक्तिशाली उपकरण है जो आपको एक साथ कई काम करने की अनुमति देता है, खासकर जब यह लंबे आईओ संचालन या गणना की बात आती है। इस लेख में, हमने रूबी और इसके विभिन्न कार्यान्वयन की कुछ संभावनाओं और सीमाओं की जांच की, और धाराओं के साथ काम को आसान बनाने के लिए दो तृतीय-पक्ष पुस्तकालयों का भी उपयोग किया।

इस प्रकार, लेख के लेखक रूबी , थ्रेड्स के साथ खेलने की सलाह देते हैं, और जब भविष्य की रेल परियोजनाओं को शुरू करते हैं, तो वैकल्पिक कार्यान्वयन - रुबी और रूबिनियस की ओर देखें।