रेल के साथ एकाधिक पृष्ठभूमि समानांतर नौकरियां चलाना

Question

रेल अनुप्रयोग पर मेरी रूबी पर मुझे समानांतर में 50 पृष्ठभूमि नौकरियों को निष्पादित करने की आवश्यकता है। प्रत्येक नौकरी एक अलग सर्वर के लिए एक टीसीपी कनेक्शन बनाता है, कुछ डेटा fecths और एक सक्रिय रिकॉर्ड ऑब्जेक्ट अद्यतन करता है।

मुझे इस कार्य को करने के लिए अलग-अलग समाधान पता हैं लेकिन उनमें से कोई भी समानांतर में है। उदाहरण के लिए, देरी_job (डीजे) एक अच्छा समाधान हो सकता है अगर यह केवल समानांतर में सभी नौकरियों को निष्पादित कर सकता है।

कोई विचार? धन्यवाद।

Answer 1

कुछ विचार ...

• सिर्फ इसलिए कि आप 50 साइटों को पढ़ने के लिए और स्वाभाविक रूप से कुछ समानांतर काम नहीं मतलब चाहते हैं की जरूरत है कि आपको 50 प्रक्रियाओं या धागे की आवश्यकता है। आपको मंदी और ऊपरी हिस्से को संतुलित करने की जरूरत है। 10 या 20 प्रक्रियाओं के बारे में कुछ साइटों को पढ़ने के बारे में कैसे?

• पर निर्भर करते हुए रूबी प्रयोग कर रहे हैं, हरे धागे के बारे में सावधान रहना होगा, आप नहीं समानांतर परिणाम आप

• आप एक रिवर्स, क्लाइंट साइड inetd है जैसे कि यह संरचना करने के लिए चाहते हो सकता चाहते हो सकता है, और सभी सर्वरों को समांतर में प्रतिक्रिया देकर समानांतर कनेक्शन प्राप्त करने के लिए connect_nonblock और IO.select का उपयोग करें। आपको वास्तव में परिणामों की समांतर प्रसंस्करण की आवश्यकता नहीं है, आपको बस समानांतर में सभी सर्वरों पर लाइन में आने की आवश्यकता है, क्योंकि वह वहीं है जहां विलंबता वास्तव में है।

तो, सॉकेट लाइब्रेरी से कुछ इस तरह ... कई बकाया कनेक्शन के लिए इसे विस्तार ...

require 'socket' 
include Socket::Constants 
socket = Socket.new(AF_INET, SOCK_STREAM, 0) 
sockaddr = Socket.sockaddr_in(80, 'www.google.com') 
begin 
    socket.connect_nonblock(sockaddr) 
    rescue Errno::EINPROGRESS 
    IO.select(nil, [socket]) 
    begin 
    socket.connect_nonblock(sockaddr) 
    rescue Errno::EISCONN 
    end 
end 
socket.write("GET/HTTP/1.0\r\n\r\n") 
# here perhaps insert IO.select. You may not need multiple threads OR multiple 
# processes with this technique, but if you do insert them here 
results = socket.read 

Answer 2

कई देरी_बॉज श्रमिकों को चलाने के लिए वास्तव में संभव है।

http://github.com/collectiveidea/delayed_job से:

# Runs two workers in separate processes. 
$ RAILS_ENV=production script/delayed_job -n 2 start 
$ RAILS_ENV=production script/delayed_job stop 

तो, सिद्धांत रूप में, तुम बस पर अमल कर सकते हैं:

$ RAILS_ENV=production script/delayed_job -n 50 start 

यह 50 प्रक्रियाओं अंडे जाएगा, हालांकि मुझे यकीन है कि नहीं कर रहा हूँ कि क्या उस पर निर्भर करता है की सिफारिश की जाएगी सिस्टम के संसाधन जो आप इसे चला रहे हैं।

---

threads का उपयोग करने का एक वैकल्पिक विकल्प होगा। बस अपनी प्रत्येक नौकरियों के लिए एक नया धागा पैदा करें।

सहन करने की एक बात यह है कि ActiveRecord थ्रेड-सुरक्षित नहीं है। आप इसे थ्रेड-सुरक्षित निम्नलिखित सेटिंग का उपयोग कर सकते हैं:

ActiveRecord::Base.allow_concurrency = true 

Answer 3

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

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

दूसरा तरीका एक ऐसा काम बनाना है जो आपके 50 समवर्ती टीसीपी अनुरोधों को चलाने के लिए कर्ल :: मल्टी का उपयोग करता है। आप यहां इसके बारे में अधिक जानकारी प्राप्त कर सकते हैं: http://curl-multi.rubyforge.org/ इस तरह, आप एक पृष्ठभूमि प्रोसेसर को अपने सभी टीसीपी अनुरोधों को समानांतर में चला सकते हैं।