थ्रेडपूल एक्ज़ीक्यूटर

"साधारण प्रोग्रामर जल्दी या बाद में इस तथ्य से पकड़ में आते हैं कि उनके पास कई छोटे कार्य हैं जिन्हें समय-समय पर करने की आवश्यकता होती है।"

"यदि आप एक खेल लिख रहे हैं, तो यह वह कार्य है जो व्यक्तिगत वर्ण करते हैं।"

"यदि आप एक वेब सर्वर लिख रहे हैं, तो यह उपयोगकर्ताओं से आने वाले विभिन्न आदेश हैं: एक फोटो अपलोड करें, इसे वांछित प्रारूप में ट्रांसकोड करें, वांछित टेम्पलेट लागू करें, आदि।"

"जल्दी या बाद में, सभी बड़े कार्य छोटे, प्रबंधनीय कार्यों के एक सेट में टूट जाते हैं।"

"तो, इस संदर्भ को देखते हुए, एक सूक्ष्म प्रश्न उठता है: आप उन सभी को कैसे प्रबंधित करने वाले हैं? क्या होगा यदि आपको एक मिनट में कई सौ कार्य करने की आवश्यकता है? प्रत्येक कार्य के लिए एक थ्रेड बनाने से कोई मतलब नहीं होगा। जावा मशीन प्रत्येक थ्रेड के लिए काफी संसाधन आवंटित करता है।"

"दूसरे शब्दों में, थ्रेड बनाने और नष्ट करने में कार्य से अधिक समय और संसाधन लग सकते हैं।"

"जावा के निर्माता इस समस्या का एक सुंदर समाधान लेकर आए: थ्रेडपूल एक्ज़ीक्यूटर ।

" ThreadPoolExecutor एक वर्ग है जिसके अंदर दो चीजें हैं:"

ए)  एक कार्य कतार, जिसे आप प्रोग्राम में उत्पन्न होने पर कार्य जोड़ सकते हैं।

बी) एक थ्रेड पूल, जो इन कार्यों को करने वाले थ्रेड्स का एक समूह है।

"क्या अधिक है, एक कार्य समाप्त होने के बाद धागे नष्ट नहीं होते हैं। इसके बजाय, जैसे ही यह प्रकट होता है, एक नया कार्य शुरू करने के लिए तैयार होने के लिए वे सो जाते हैं।"

"जब आप एक थ्रेडपूल एक्ज़ीक्यूटर बनाते हैं, तो आप बनाए जाने वाले थ्रेड्स की अधिकतम संख्या और कतारबद्ध किए जा सकने वाले कार्यों की अधिकतम संख्या निर्धारित कर सकते हैं। दूसरे शब्दों में, आप थ्रेड्स की संख्या को 10 तक सीमित कर सकते हैं, उदाहरण के लिए, और की संख्या कतारबद्ध कार्य 100 तक।"

"इस प्रकार थ्रेडपूल एक्ज़ीक्यूटर काम करता है:"

1)  जब आप कोई नया कार्य जोड़ते हैं, तो उसे कतार के अंत में रखा जाता है।

2)  यदि कतार भरी हुई है, तो एक अपवाद फेंका जाता है।

3)  एक कार्य पूरा करने के बाद, प्रत्येक थ्रेड कतार से अगला कार्य लेता है और इसे निष्पादित करना शुरू कर देता है।

4) यदि कतार में कोई कार्य नहीं है, तो नए कार्य जोड़े जाने तक एक थ्रेड सो जाता है।

"दृष्टिकोण, जहां हम वर्कर थ्रेड्स की संख्या को सीमित करते हैं, इसमें फायदेमंद है कि हमारे पास जितने अधिक थ्रेड्स हैं, उतना ही वे एक-दूसरे के साथ हस्तक्षेप करते हैं। 5-10 वर्कर थ्रेड्स और कार्यों की लंबी कतार की तुलना में यह अधिक प्रभावी है। कार्यों में वृद्धि के लिए 100 धागे बनाने के लिए, जो संसाधनों के लिए एक दूसरे के साथ प्रतिस्पर्धा करेंगे: मेमोरी, प्रोसेसर समय, डेटाबेस एक्सेस इत्यादि।"

"यहाँ थ्रेडपूल एक्ज़ीक्यूटर के कार्य का एक उदाहरण है:"

ExecutorService service = Executors.newFixedThreadPool(2);

for(int i = 0; i < 10; i++)
{
 service.submit(new Runnable() {
    public void run()
    {
     // Here we download something big from the Internet.
    }
 });
}

"उह, मैं इसे नहीं देखता ..."

"एक थ्रेडपूल एक्ज़ीक्यूटर ऑब्जेक्ट तब बनाया जाता है जब newFixedThreadPool मेथड को कॉल किया जाता है।"

तो, इसका उपयोग करना बहुत आसान है। जैसे ही आप सबमिट विधि के साथ इसमें कोई कार्य जोड़ते हैं, यह:

ए)  कार्य को अंजाम देने के लिए एक सोए हुए धागे को जगाता है, यदि कोई है।

बी)  यदि कोई प्रतीक्षा धागा नहीं है, तो यह कार्य के लिए एक नया निर्माण करता है।

सी)  यदि धागे की अधिकतम संख्या तक पहुँच जाता है, तो यह कार्य को कतार के अंत में रखता है।

"मैंने जानबूझकर शामिल किया है" यहां हम उदाहरण में इंटरनेट से कुछ बड़ा डाउनलोड करते हैं। हमारे इंटरनेट कनेक्शन की बैंडविड्थ सीमा द्वारा रोका जाएगा। इस मामले में, कुछ धागे पर्याप्त होना चाहिए। उपरोक्त उदाहरण में आप यही देखते हैं: "

ExecutorService service = Executors.newFixedThreadPool(2);

"यह पता चला है कि कार्यों के एक समूह के साथ काम करना इतना मुश्किल नहीं है।"

"हाँ। जितना आप सोच सकते हैं उससे भी आसान है। लेकिन किम आपको इसके बारे में बताएगी।"