ThreadPoolExecutor

"सामान्य प्रोग्रामर लवकर किंवा नंतर या वस्तुस्थितीकडे लक्ष देतात की त्यांच्याकडे अनेक लहान कार्ये आहेत जी वेळोवेळी पूर्ण करणे आवश्यक आहे."

"तुम्ही एखादा खेळ लिहित असाल, तर वैयक्तिक पात्रांनी केलेल्या कृती."

"जर तुम्ही वेब सर्व्हर लिहित असाल, तर वापरकर्त्यांकडून वेगवेगळ्या कमांड येत आहेत: फोटो अपलोड करा, तो इच्छित फॉरमॅटमध्ये ट्रान्सकोड करा, इच्छित टेम्पलेट लागू करा इ.

"लवकर किंवा नंतर, सर्व मोठी कार्ये लहान, आटोपशीर कार्यांच्या संचामध्ये विभागली जातात."

"म्हणून, हा संदर्भ लक्षात घेता, एक सूक्ष्म प्रश्न उद्भवतो: तुम्ही ते सर्व कसे व्यवस्थापित कराल? तुम्हाला एका मिनिटात शंभर कार्ये करायची असल्यास काय करावे? प्रत्येक कार्यासाठी एक धागा तयार करणे फारसा अर्थपूर्ण नाही. Java मशीन प्रत्येक थ्रेडसाठी भरपूर संसाधने वाटप करते."

"दुसर्‍या शब्दात, थ्रेड तयार करणे आणि नष्ट करणे या कामापेक्षा जास्त वेळ आणि संसाधने लागू शकतात."

"जावाच्या निर्मात्यांनी या समस्येवर एक सुंदर उपाय शोधून काढला: ThreadPoolExecutor .

" ThreadPoolExecutor एक वर्ग आहे ज्यामध्ये दोन गोष्टी आहेत:"

अ)  कार्य रांग, ज्यामध्ये तुम्ही कार्य जोडू शकता जसे ते प्रोग्राममध्ये उद्भवतात.

ब) थ्रेड पूल, जो थ्रेड्सचा एक समूह आहे जो ही कार्ये करतो.

"इतकंच काय, एखादं काम पूर्ण झाल्यावर धागे नष्ट होत नाहीत. त्याऐवजी, नवीन कार्य दिसल्याबरोबर सुरू करण्यासाठी तयार होण्यासाठी ते झोपी जातात."

"जेव्हा तुम्ही ThreadPoolExecutor तयार करता, तेव्हा तुम्ही तयार करायच्या थ्रेड्सची कमाल संख्या आणि रांगेत ठेवता येणारी जास्तीत जास्त कार्ये सेट करू शकता. दुसऱ्या शब्दांत, तुम्ही थ्रेडची संख्या 10 पर्यंत मर्यादित करू शकता, उदाहरणार्थ, आणि रांगेत कार्ये १०० पर्यंत."

" ThreadPoolExecutor कसे कार्य करते:"

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.
    }
 });
}

"अरे, मला दिसत नाहीये..."

" नवीन FixedThreadPool पद्धत कॉल केल्यावर ThreadPoolExecutor ऑब्जेक्ट तयार केला जातो."

त्यामुळे, ते वापरण्यास अतिशय सोपे आहे. सबमिट पद्धतीसह तुम्ही त्यात एखादे कार्य जोडताच, ते:

अ)  कार्य पूर्ण करण्यासाठी झोपलेला धागा, जर तेथे असेल तर जागृत करतो.

ब)  प्रतीक्षा धागा नसल्यास, ते कार्यासाठी एक नवीन तयार करते.

क)  जर जास्तीत जास्त थ्रेड्सची संख्या गाठली असेल, तर ते कार्य रांगेच्या शेवटी ठेवते.

"मी मुद्दाम उदाहरणामध्ये "येथे आम्ही इंटरनेटवरून काहीतरी मोठे डाउनलोड करतो" समाविष्ट केले आहे. जर आमच्याकडे 100 कार्ये «इंटरनेटवरून काहीतरी मोठे डाउनलोड करा» असतील, तर ती एकाच वेळी चालवण्यात काहीच अर्थ नाही—आम्ही' आमच्या इंटरनेट कनेक्शनच्या बँडविड्थ मर्यादेने रोखले जाईल. या प्रकरणात, दोन थ्रेड पुरेसे असावेत. वरील उदाहरणामध्ये तुम्ही हे पहात आहात:"

ExecutorService service = Executors.newFixedThreadPool(2);

"असे दिसून आले की अनेक कार्यांसह कार्य करणे इतके अवघड नाही."

"हो. तुमच्या कल्पनेपेक्षाही सोपे. पण किम तुम्हाला त्याबद्दल सांगेल."