रूबी में फाइबर के बारे में सभी को क्या पता होना चाहिए?

यदि आप अपने रूबी प्रोजेक्ट्स से सबसे अधिक प्रदर्शन प्राप्त करना चाहते हैं तो हमें फाइबर और उनके काम करने के तरीके का पता लगाना होगा।

आइए एक आसान सवाल से शुरू करते हैं...

फाइबर क्या होते हैं?

फाइबर श्रमिक हैं, वे कोड चलाते हैं और अपनी प्रगति का ट्रैक रखते हैं। दूसरे शब्दों में, फाइबर एक समवर्ती तंत्र हैं।

हाँ!

बिल्कुल धागों की तरह। इस अंतर के साथ कि आप धागों की तुलना में तंतुओं पर अधिक नियंत्रण रखते हैं।

किस अर्थ में आपका नियंत्रण अधिक है?

खैर।

आपका ऑपरेटिंग सिस्टम तय करता है कि कब थ्रेड चलाना है और कब उन्हें रोकना है।

फाइबर के साथ ऐसा नहीं है!

आपको फाइबर को ठीक से बताना होगा कि कब दौड़ना है और कब रुकना है।

फाइबर बनाम थ्रेड्स

थ्रेड ऐसा महसूस करते हैं कि वे पृष्ठभूमि में चल रहे हैं, अपना काम कर रहे हैं।

फाइबर ऐसा नहीं करते हैं।

जब एक फाइबर चल रहा होता है तब तक यह मुख्य कार्यक्रम बन जाता है जब तक कि आप इसे रोक नहीं देते।

आइए एक कोड उदाहरण देखें!

फाइबर का उपयोग करना:एक उदाहरण

Fiber.new . के साथ फाइबर बनाएं और एक ब्लॉक।

उदाहरण :

f = Fiber.new { puts 1 }

फिर resume . का उपयोग करके फाइबर को चलाएं विधि।

इसे पसंद करें :

f.resume

यह प्रिंट करता है 1 और यह आपके मुख्य कार्यक्रम पर नियंत्रण लौटाता है।

लेकिन आप फाइबर को कैसे रोकते हैं?

Fiber.yield . के साथ विधि, जो yield . से भिन्न है ब्लॉक के लिए प्रयुक्त कीवर्ड।

उदाहरण :

f = Fiber.new { puts 1; Fiber.yield; puts 2 }

f.resume
# 1

f.resume
# 2

यह 1 प्रिंट करेगा फाइबर शुरू करने के बाद resume , फिर रुकें।

अगर आप resume को कॉल करते हैं फिर से…

यह ठीक वहीं से जारी रहेगा जहां से यह छोड़ा था और प्रिंट करें 2 ।

नोट :इस फाइबर को फिर से शुरू करने से FiberError: dead fiber called क्योंकि चलाने के लिए और कोई कोड नहीं है।

इसीलिए रेशे उपयोगी होते हैं!

कॉलिंग Fiber.yield एक फाइबर के अंदर एक पॉज़ बटन दबाने जैसा है। आपको लूप के बीच में या फाइबर के ब्लॉक के अंदर आपके द्वारा लिखे गए किसी भी कोड को रोकने की अनुमति देता है।

फाइबर और लूप्स:अंतहीन अनुक्रम

अनंत अनुक्रम बनाने के लिए हम इस "रोकें बटन" प्रभाव का उपयोग कर सकते हैं।

सामग्री :

• फाइबर
• लूप
• काउंटर

उदाहरण के लिए, भाज्य संख्याएं :

factorial =
Fiber.new do
  count = 1

  loop do
    Fiber.yield (1..count).inject(:*)
    count += 1
  end
end

resume . के साथ आप जितनी बार चाहें इस फाइबर का उपयोग कर सकते हैं विधि, क्रम में अगला नंबर प्राप्त करने के लिए।

उदाहरण :

Array.new(5) { factorial.resume }

# [1, 2, 6, 24, 120]

बढ़िया!

फाइबर और IO:Async ऑपरेशंस

नेटवर्क कनेक्शन जैसी चीज़ों के लिए धागों की तुलना में फाइबर तेज़ और अधिक कुशल होते हैं।

क्यों?

क्योंकि रेशों के परिणामस्वरूप कम संदर्भ स्विच होते हैं।

एक संदर्भ स्विच तब होता है जब सीपीयू वर्तमान कार्य से दूसरे कार्य में बदल जाता है।

इसकी एक छोटी सी लागत है, लेकिन यह बढ़ जाती है!

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

अच्छा लगता है?

आप अभी फाइबर का उपयोग शुरू कर सकते हैं :

• IO.select . के साथ विधि + रिएक्टर डिजाइन पैटर्न
• एसिंक रत्न के साथ
• फाल्कन एप्लिकेशन सर्वर के साथ

याद रखें…

कोई जादू की गोलियां नहीं हैं, लेकिन यह परीक्षण के लायक है और देखें कि फाइबर आपके लिए क्या कर सकते हैं 🙂

सारांश

आपने रूबी में फाइबर के बारे में सीखा है! फाइबर आपको कोड की एक इकाई बनाने की अनुमति देता है जिसे आपकी मर्जी से रोका और फिर से शुरू किया जा सकता है ।

अब इसे आजमाने की आपकी बारी है।

पढ़ने के लिए धन्यवाद!