रूबी फाइबर्स मास्टर करें: बारीक नियंत्रण के साथ प्रदर्शन और कंकरेंसी बढ़ाएं

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

आइए एक सरल प्रश्न से शुरू करें...

फाइबर्स क्या हैं?

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

हाँ!

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

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

खैर।

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

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

आपको फाइबर को ठीक से बताना होगा कि कब चलना है और कब रुकना है।

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

थ्रेड्स ऐसा महसूस करते हैं जैसे वे बैकग्राउंड में चल रहे हैं, अपना काम कर रहे हैं।

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

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

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

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

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 

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

यदि आप 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: एसिंक ऑपरेशन्स

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

क्यों?

क्योंकि फाइबर्स के परिणामस्वरूप कम कॉन्टेक्स्ट स्विच होते हैं।

कॉन्टेक्स्ट स्विच तब होता है जब CPU वर्तमान कार्य से दूसरे कार्य में बदलता है।

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

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

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

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

• IO.select मेथड + रिएक्टर डिज़ाइन पैटर्न के साथ
• async जेम के साथ
• falcon एप्लिकेशन सर्वर के साथ

याद रखें...

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

सारांश

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

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

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