मैं एनआईओ का उपयोग करने के लिए हमारे जावा कोड को बदलने की प्रक्रिया में हूं, लेकिन मुझे इसे डिजाइन करने का सबसे अच्छा तरीका नहीं है।एनआईओ कार्यान्वयन के लिए सर्वश्रेष्ठ मॉडल?
मेरा प्रारंभिक दृष्टिकोण चयनकर्ता धागे का एक पूल बनाना था। थ्रेड को आवश्यकतानुसार शुरू/मार दिया जाता है, और चैनल एक चयनकर्ता धागे में पंजीकृत होते हैं जब वे राउंड-रॉबिन फैशन में जुड़े/स्वीकार किए जाते हैं। वहां से, प्रत्येक थ्रेड ब्लॉक चुनिंदा() पर, और जब जागृत हो जाए तो प्रत्येक चैनल के साथ चयनित कॉलबैक चलाएगा जिसमें चयनित कुंजी है।
इस "एकाधिक चयनकर्ता धागे" डिज़ाइन के अतिरिक्त, मैंने लोगों को एक एकल चयनकर्ता थ्रेड और प्रेषण धागे का एक पूल उपयोग करने के लिए भी कहा है। जब एक आईओ ऑपरेशन करने के लिए तैयार होता है, तो चयनकर्ता एक प्रेषक धागा को सूचित करता है, जो तब अनुरोध को संसाधित करता है। इस मॉडल को आईओ थ्रेड को अवरुद्ध नहीं करने का लाभ है, लेकिन अब हम सभी आईओ को एक थ्रेड में मजबूर कर रहे हैं और प्रेषक में सिंक्रनाइज़ेशन/इवेंट कतार से निपट रहे हैं।
इसके अतिरिक्त मैं प्रत्येक चैनल को पढ़ने के लिए सीधे कॉलबैक में पास करने के लिए एक प्रत्यक्ष बाइट बफर का उपयोग नहीं कर पाऊंगा। इसके बजाय मुझे प्रत्येक बार एक सरणी में पढ़ने और रीसेट होने पर डेटा कॉपी करना होगा। (मुझे लगता है ..)
इसे लागू करने का सबसे अच्छा तरीका क्या है?
प्रदर्शन और मापनीयता। बहुत कम धागे, और यह हमारे डिजाइन को सरल बनाना चाहिए। –
रिएक्टर पैटर्न एक बहुत अच्छी पसंद है। इस डिजाइन के कुछ कार्यान्वयन हैं जो I/O ईवेंट को संभालने के लिए एकाधिक धागे का उपयोग करते हैं। ये डिज़ाइन खराब हैं और गैर-अवरुद्ध एसिंक्रोनस I/O के उद्देश्य को हराते हैं। उच्च प्रदर्शन और स्केलेबल सर्वर के लिए डिज़ाइन लिखते समय आप एसिंक्रोनस I/O कॉल का उपयोग करना चाहते हैं और इसे सभी को एक थ्रेड पर रखें - 'चयनकर्ता' थ्रेड। –