मल्टीथ्रेडेड रेक कार्य

Question

मैं एक रेक कार्य लिख रहा हूं जिसे हर बार (संभवतः भविष्य में हर 30 सेकंड) कहा जाता है, और यह एक मतदान एपीआई एंडपॉइंट (हमारे डेटाबेस में प्रति उपयोगकर्ता) से संपर्क करता है। जाहिर है, यह एक धागे के रूप में कुशल नहीं है, लेकिन क्या यह बहुसंख्यक संभव है? यदि नहीं, तो क्या कोई अच्छी घटना-आधारित HTTP लाइब्रेरी है जो काम पूरा करने में सक्षम होगी?

Answer 1

मैं एक रेक कार्य से जब भी

रेल की स्टार्टअप समय सावधान रहें हर मिनट (भविष्य में संभवतः हर 30 सेकंड) कहा जाएगा लिख ​​रहा हूँ, यह एक forking के उपयोग करने के लिए बेहतर हो सकता है इस तरह के Resque या Sidekiq के रूप में मॉडल, बचाव https://github.com/bvandenbos/resque-scheduler जो आपको क्या चाहिए ऐसा करने में सक्षम होना चाहिए प्रदान करता है, मैं Sidekiq बारे में बात नहीं कर सकते, लेकिन मुझे यकीन है कि यह उपलब्ध कुछ इसी तरह की है हूँ

(Sidekiq Resque की तुलना में काफी नया है)

जाहिर है, यह एक धागा के रूप में कुशल नहीं है , लेकिन क्या यह multithread संभव है? यदि नहीं, तो क्या कोई अच्छी घटना-आधारित HTTP लाइब्रेरी है जो काम पूरा करने में सक्षम होगी? कोई

# 
# Find each returns 50 by default, you can pass options 
# to optimize that for larger (or smaller) batch sizes 
# depending on your available RAM 
# 
Users.find_each do |batch_of_users| 
    # 
    # Find each returns an Enumerable collection of users 
    # in that batch, they'll be always smaller than or 
    # equal to the batch size chosen in `find_each` 
    # 
    # 
    # We collect a bunch of new threads, one for each 
    # user, eac 
    # 
    batch_threads = batch_of_users.collect do |user| 
    # 
    # We pass the user to the thread, this is good 
    # habit for shared variables, in this case 
    # it doesn't make much difference 
    # 
    Thread.new(user) do |u| 
     # 
     # Do the API call here use `u` (not `user`) 
     # to access the user instance 
     # 
     # We shouldn't need to use an evented HTTP library 
     # Ruby threads will pass control when the IO happens 
     # control will return to the thread sometime when 
     # the scheduler decides, but 99% of the time 
     # HTTP and network IO are the best thread optimized 
     # thing you can do in Ruby. 
     # 
    end 
    end 
    # 
    # Joining threads means waiting for them to finish 
    # before moving onto the next batch. 
    # 
    batch_threads.map(&:join) 
end 

यह शुरू कर देंगे:

मैं आप अपने खोजक प्रक्रिया को और अधिक कुशल बनाने की युक्तियों के लिए ActiveRecord's find_each को देखो एक बार आप अपने बैचों आप आसानी से इस तरह के रूप धागे का उपयोग कर कुछ कर सकते हैं है सुझाव देंगे धागे के batch_size से अधिक, समाप्त करने के लिए प्रत्येक batch_size के बाद प्रतीक्षा करें।

ऐसा कुछ करना संभव होगा, लेकिन फिर आपके पास अनियंत्रित संख्या में धागे होंगे, यहां एक विकल्प है जो आपको यहां से लाभ हो सकता है, यह थ्रेडपूल सहित बहुत अधिक जटिल हो जाता है, और काम की साझा सूची ऐसा करें, मैंने इसे गिटूब के रूप में पोस्ट किया है, इसलिए स्पैम स्टैक ओवरफ्लो नहीं है: https://gist.github.com/6767fbad1f0a66fa90ac

Answer 2

मैं sidekiq का उपयोग करने का सुझाव दूंगा जो मल्टीथ्रेडिंग में बहुत अच्छा है। फिर आप API को मतदान के लिए प्रति उपयोगकर्ता अलग-अलग नौकरियां लगा सकते हैं। clockwork का उपयोग उन नौकरियों को बनाने के लिए किया जा सकता है जिन्हें आप पुनरावर्ती करते हैं।