रोजमर्रा के काम में, ऐसा अक्सर नहीं होता है कि आपको java.util.concurrent मल्टीथ्रेडिंग पैकेज से निपटना पड़ता है। कभी-कभी जावा 1.4.2 के उपयोग पर डिज़ाइन प्रतिबंध होते हैं, जहां यह पैकेज नहीं होता है, लेकिन ज्यादातर अक्सर पर्याप्त सामान्य सिंक्रनाइज़ेशन होता है और अलौकिक की आवश्यकता नहीं होती है। सौभाग्य से, कार्य समय-समय पर उत्पन्न होते हैं, जो आपको थोड़ा दिमाग के बारे में सोचते हैं और या तो एक साइकिल या रवाज को javadocs के माध्यम से लिखते हैं और कुछ अधिक उपयुक्त पाते हैं। बाइक के साथ कोई समस्या नहीं है - बस ले लो और लिखो, क्योंकि मल्टीथ्रेडिंग में सुपर जटिल कुछ भी नहीं है। दूसरी ओर, कम कोड - कम बग। इसके अलावा, उनके दाहिने दिमाग में कोई भी मल्टीथ्रेडिंग के लिए यूनिट परीक्षण नहीं लिखता है, क्योंकि ये पहले से ही पूर्ण एकीकरण परीक्षण हैं सभी आगामी परिणामों के साथ प्राप्त किए गए हैं।

किसी विशिष्ट मामले के लिए क्या चुनना है? एक ज़पारकी और समय सीमा की शर्तों में सभी java.util.concurrent को कवर करना मुश्किल है। कुछ इसी तरह का चयन करता है और जाओ! तो, धीरे-धीरे, ArrayBlockingQueue, ConcurrentHashMap, AtomicInteger, Collections.synchronizedList (नई LinkedList ()) और अन्य दिलचस्प चीजें कोड में दिखाई देती हैं। कभी सही, कभी नहीं। किसी समय में, आपको एहसास होना शुरू होता है कि जावा में 95% से अधिक मानक कक्षाएं उत्पाद विकास में बिल्कुल भी उपयोग नहीं की जाती हैं। संग्रह, आदिम, बाइट्स को एक स्थान से दूसरे स्थान पर स्थानांतरित करना, हाइबरनेट, स्प्रिंग या ईजेबी, कुछ अन्य पुस्तकालय और वॉयला, आवेदन तैयार है।

कम से कम किसी तरह ज्ञान को सुव्यवस्थित करने और विषय में प्रवेश की सुविधा के लिए, नीचे मल्टीथ्रेडिंग के साथ काम करने के लिए कक्षाओं का अवलोकन है। मैं मुख्य रूप से अपने लिए एक धोखा पत्र के रूप में लिखता हूं। और अगर कोई और सूट करता है, तो यह आम तौर पर अद्भुत है।

बीज के लिए

मैं आपको कुछ दिलचस्प लिंक तुरंत दूंगा। मल्टीथ्रेडिंग में थोड़ा तैरने वालों के लिए पहला। "उन्नत" प्रोग्रामर के लिए दूसरा - शायद यहां कुछ उपयोगी है।

• जावा कॉनएरेबिलिटी ट्यूटोरियल
• डग ले द्वारा जावा में समवर्ती प्रोग्रामिंग

Java.util.concurrent पैकेज के लेखक के बारे में थोड़ा

यदि किसी ने कभी भी java.util.concurrent कक्षाओं के लिए स्रोत कोड खोला, तो वे मदद नहीं कर सकते थे लेकिन लेखकों में डौग ली (डग ली), प्रोफेसर ओस्वेगो (ओसूइगो), न्यूयॉर्क विश्वविद्यालय। उनके सबसे प्रसिद्ध घटनाक्रमों की सूची में जावा संग्रह और उपयोग शामिल हैं। वर्तमान में , जो एक रूप में या किसी अन्य को मौजूदा जेडीके में परिलक्षित होते थे। उन्होंने डायनामिक मेमोरी आवंटन के लिए dlmalloc कार्यान्वयन भी लिखा। साहित्य में जावा में मल्टीथ्रेडिंग कॉनकंट्रेटिंग प्रोग्रामिंग पर एक पुस्तक थी : डिज़ाइन सिद्धांत और पैटर्न, दूसरा संस्करण । अधिक विवरण उसके होम पेज पर पाए जा सकते हैं।


2010 में जेवीएम भाषा शिखर सम्मेलन में डग ले का प्रदर्शन।

ऊपर तक

जब वे java.util.concurrent पर नज़र रखते थे, तो शायद कुछ को कुछ अराजकता का अहसास होता था। एक पैकेज में, पूरी तरह से अलग कार्यक्षमता के साथ अलग-अलग वर्गों को मिलाया जाता है, जिससे यह समझना मुश्किल हो जाता है कि प्रासंगिक क्या है और यह कैसे काम करता है। इसलिए, आप एक कार्यात्मक विशेषता के अनुसार वर्गों और इंटरफेस को योजनाबद्ध रूप से विभाजित कर सकते हैं, और फिर विशिष्ट भागों के कार्यान्वयन पर जा सकते हैं।



समवर्ती संग्रह - संग्रह का एक संग्रह जो java.bilil पैकेज से मानक सार्वभौमिक संग्रह की तुलना में एक बहु-थ्रेडेड वातावरण में अधिक कुशलता से काम करता है। बेस रैपर कलेक्शंस के बजाय। एसिंक्रोनाइज़लाइज़लिस्ट पूरे संग्रह तक पहुंच को अवरुद्ध करने के साथ, डेटा सेगमेंट पर लॉक का उपयोग किया जाता है या प्रतीक्षा-मुक्त एल्गोरिदम का उपयोग करके डेटा के समानांतर रीडिंग के लिए काम को अनुकूलित किया जाता है।

कतार - बहु-समर्थन के साथ गैर- ब्लॉकिंग और अवरुद्ध कतार। गैर-अवरुद्ध कतारें थ्रेड्स को अवरुद्ध किए बिना गति और संचालन के लिए तेज की जाती हैं। अवरोधक कतारों का उपयोग तब किया जाता है जब आपको निर्माता या उपभोक्ता थ्रेड्स को "धीमा" करने की आवश्यकता होती है, यदि कोई शर्तें पूरी नहीं होती हैं, उदाहरण के लिए, कतार खाली है या फिर से ब्रांडेड है, या यदि कोई मुफ्त उपभोक्ता नहीं है तो।

सिंक्रोनाइज़र - थ्रेड सिंक्रोनाइज़ेशन के लिए सहायक उपयोगिताओं। वे "समानांतर" कंप्यूटिंग में एक शक्तिशाली हथियार हैं।

एक्ज़ीक्यूटर्स - थ्रेड पूल बनाने के लिए उत्कृष्ट रूपरेखाएं हैं, परिणाम प्राप्त करने के साथ अतुल्यकालिक कार्यों को शेड्यूल करना।

ताले - मूल सिंक्रनाइज़, प्रतीक्षा, सूचना, InformAll की तुलना में प्रवाह के सिंक्रनाइज़ेशन के वैकल्पिक और अधिक लचीले तंत्र का प्रतिनिधित्व करता है।

एटॉमिक्स - प्राथमिक और लिंक पर परमाणु संचालन के लिए समर्थन के साथ कक्षाएं।

1. समवर्ती संग्रह

CopyOnWrite संग्रह

नाम अपने लिए बोलता है। संग्रह को जोड़ने (जोड़ने, सेट करने, हटाने) के लिए सभी ऑपरेशन आंतरिक सरणी की एक नई प्रतिलिपि के निर्माण की ओर ले जाते हैं। यह सुनिश्चित करता है कि जब संग्रह के माध्यम से पुनरावृत्ति होती है, तो ConcurrentModificationException को फेंका नहीं जाएगा। यह याद रखना चाहिए कि किसी सरणी की प्रतिलिपि बनाते समय, केवल ऑब्जेक्ट्स (उथले प्रतिलिपि) के संदर्भ (लिंक) की प्रतिलिपि बनाई जाती है, झुकाव। तत्व क्षेत्रों तक पहुंच धागा-सुरक्षित नहीं है। CopyOnWrite संग्रह का उपयोग करने के लिए सुविधाजनक है जब लेखन संचालन काफी दुर्लभ हैं, उदाहरण के लिए, जब श्रोताओं की सदस्यता तंत्र को लागू करना और उनके माध्यम से गुजरना।

CopyOnWriteArrayList <E> - ArrayList का स्ट्रीम सेफ एनालॉग, CopyOnWrite एल्गोरिथ्म के साथ लागू किया गया।
CopyOnWriteArraySet <E> - आधार के रूप में CopyOnWriteArrayList का उपयोग करके, सेट इंटरफ़ेस का कार्यान्वयन। CopyOnWriteArrayList के विपरीत, कोई अतिरिक्त विधियाँ नहीं हैं।

स्केलेबल नक्शे

मल्टीप्रेडिंग और स्केलेबिलिटी के लिए बेहतर सपोर्ट के साथ हैशपॉप, ट्रीपाइप का बेहतर इम्प्लीमेंटेशन।

समवर्ती नक्शा <के, वी> - एक इंटरफ़ेस जो कई अतिरिक्त परमाणु संचालन के साथ मानचित्र का विस्तार करता है।

समवर्ती हाशमी <के, वी> - हैशटेबल के आधार पर हैशटेबल और सिंक्रोनाइज़्ड ब्लॉक्स के विपरीत, डेटा को हैश कीज़ द्वारा विभाजित सेगमेंट के रूप में प्रस्तुत किया जाता है। नतीजतन, डेटा तक पहुंच खंडों द्वारा बंद हो जाती है, और एक वस्तु से नहीं। इसके अलावा, पुनरावृत्तियाँ एक विशिष्ट समय स्लाइस के लिए डेटा प्रस्तुत करती हैं और एक समवर्ती माडिफिकेशन अपवाद को नहीं फेंकती हैं। समवर्ती हाशपाट का वर्णन यहाँ हब्रतोपिका में अधिक विस्तार से किया गया है ।
कॉन्ट्रैक्‍टैनेवेब्‍लेब्‍प <<K, V> - NavigableMap इंटरफ़ेस का विस्तार करता है और समवर्ती NavigableMap वस्तुओं के उपयोग को रिटर्न मान के रूप में उपयोग करता है। सभी पुनरावृत्तियों को उपयोग करने के लिए सुरक्षित घोषित किया गया है और एक समवर्ती मण्डलीकरण अपवाद को फेंकना नहीं है।

समवर्तीSkLListMap <के, वी> - यह मल्टीप्रेडिंग समर्थन के साथ ट्रीपैप का एक एनालॉग है। डेटा में मुख्य और गारंटीकृत औसत लॉग (N) प्रदर्शन के लिए SortKey, get, put, remove और इसी तरह के अन्य ऑपरेशन शामिल हैं। SkipList ऑपरेशन एल्गोरिथ्म विकी और हैबर पर वर्णित है।

समवर्तीSkipListSet <E> - समवर्तीSkipListMap पर आधारित सेट इंटरफ़ेस का कार्यान्वयन।

2. कतार

गैर-अवरुद्ध कतारें

लिंक नोड्स पर थ्रेड-सुरक्षित और गैर-अवरुद्ध क्यू कार्यान्वयन।

समवर्तीलिखित क्यू <ई> - कचरा उठाने वाले के साथ काम करने के लिए अनुकूलित माइकल और स्कॉट से कार्यान्वयन एक प्रतीक्षा-मुक्त एल्गोरिथ्म का उपयोग करता है। यह एल्गोरिथ्म काफी कुशल है और, सबसे महत्वपूर्ण, बहुत तेज, क्योंकि कैस पर बनाया गया। आकार () विधि लंबे समय तक काम कर सकती है, झुकाव कर सकती है। हर समय इसे खींचना बेहतर है। एल्गोरिथ्म का विस्तृत विवरण यहां पाया जा सकता है ।

समवर्तीलिखा <ई> - ड्यूक डबल एंडेड कतार के लिए खड़ा है और "डेक" के रूप में पढ़ता है। इसका मतलब है कि डेटा को दोनों तरफ जोड़ा और निकाला जा सकता है। तदनुसार, वर्ग दोनों ऑपरेटिंग मोड का समर्थन करता है: FIFO (फर्स्ट इन फर्स्ट आउट) और LIFO (लास्ट इन फर्स्ट आउट)। व्यवहार में, समवर्तीलिंकड का उपयोग केवल तभी किया जाना चाहिए जब आपको LIFO की आवश्यकता हो, क्योंकि नोड्स की द्वि-दिशात्मकता के कारण, यह वर्ग समवर्तीLinkedQueue की तुलना में प्रदर्शन में 40% खो देता है।

कतारों को अवरुद्ध करना

ब्लॉकिंग क्यू <ई> - जब बड़े डेटा स्ट्रीम के माध्यम से स्ट्रीम करते हैं, तो समवर्ती लाईन क्यू का उपयोग स्पष्ट रूप से पर्याप्त नहीं है। यदि डेटा के प्रवाह के साथ सामना करने के लिए कतार से निकलने वाली धाराएँ समाप्त हो जाती हैं, तो आप जल्दी से मेमोरी या अधिभार IO / Net से बाहर निकल सकते हैं ताकि प्रदर्शन कई बार गिर जाए जब तक कि सिस्टम समय-समय पर क्रैश हो जाता है या सिस्टम में मुक्त डिस्क्रिप्टर की कमी के कारण। ऐसे मामलों के लिए, आपको कतार का आकार निर्धारित करने की क्षमता के साथ या शर्तों पर ताले के साथ एक कतार की आवश्यकता होती है। यहाँ BlockingQueue इंटरफ़ेस दिखाई देता है, उपयोगी कक्षाओं के पूरे सेट के लिए मार्ग प्रशस्त करता है। कतार का आकार निर्धारित करने की क्षमता के अलावा, नए तरीके जोड़े गए हैं जो कतार के गैर-भरने या अतिप्रवाह के लिए अलग-अलग प्रतिक्रिया देते हैं। इसलिए, उदाहरण के लिए, जब एक तत्व को एक अतिप्रवाहित कतार में जोड़ते हैं, तो एक विधि एक IllegalStateException को फेंक देगी, दूसरा गलत वापस आ जाएगा, तीसरा स्ट्रीम को तब तक अवरुद्ध करेगा जब तक कि कोई स्थान दिखाई नहीं देता, चौथा स्ट्रीम को ब्लॉकआउट करेगा और यदि स्थान दिखाई नहीं देता है तो वापस आ जाएगा। यह भी ध्यान देने योग्य है कि अवरुद्ध कतारें शून्य मानों का समर्थन नहीं करती हैं, जैसा कि यह मान पोल विधि में टाइमआउट संकेतक के रूप में उपयोग किया जाता है।

ArrayBlockingQueue <E> - क्लासिक रिंग बफर पर निर्मित एक अवरुद्ध कतार वर्ग। कतार के आकार के अलावा, ताले की "ईमानदारी" का प्रबंधन करने की क्षमता उपलब्ध है। यदि उचित = गलत (डिफ़ॉल्ट) है, तो थ्रेड्स के अनुक्रम की गारंटी नहीं है। "ईमानदारी" के बारे में अधिक जानकारी रेन्ट्रेंटलॉक के विवरण में पाई जा सकती है।

DelayQueue <E विस्तार से विलंबित> - बल्कि एक विशिष्ट वर्ग जो आपको विलंबित इंटरफ़ेस के getDelay विधि के माध्यम से प्रत्येक आइटम में परिभाषित एक निश्चित देरी के बाद ही कतार से आइटम खींचने की अनुमति देता है।

लिंक्डब्लॉकिंग क्यू <ई> - लिंक नोड्स पर एक अवरुद्ध कतार, "दो लॉक कतार" एल्गोरिथ्म पर लागू किया गया: एक ताला जोड़ने के लिए, दूसरा तत्व बाहर खींचने के लिए। ArrayBlockingQueue की तुलना में दो तालों के कारण, यह वर्ग उच्च प्रदर्शन दिखाता है, लेकिन इसकी मेमोरी खपत अधिक है। कतार का आकार निर्माता और डिफ़ॉल्ट के माध्यम से Integer.MAX_VALUE को निर्दिष्ट किया गया है।

प्रायोरिटीब्लॉकिंग क्यू <ई> - यह प्रायोरिटी क्यू पर एक मल्टी-थ्रेडेड रैपर है। जब किसी तत्व को कतार में डाला जाता है, तो इसका क्रम तुलनित्र के तर्क या तत्वों के लिए तुलनात्मक इंटरफ़ेस के कार्यान्वयन के अनुसार निर्धारित किया जाता है। सबसे छोटा तत्व पहले कतार से बाहर आता है।

सिंक्रोनसक्यू <ई> - यह लाइन एक के सिद्धांत पर काम करती है, एक बाईं ओर। प्रत्येक इन्सर्ट ऑपरेशन "प्रोड्यूसर" स्ट्रीम को तब तक ब्लॉक करता है जब तक "कंज्यूमर" स्ट्रीम आइटम को कतार से बाहर नहीं निकालता है और इसके विपरीत, "उपभोक्ता" तब तक इंतजार करता है जब तक कि "निर्माता" आइटम को सम्मिलित नहीं करता है।

अवरोधक <ई> - एक इंटरफ़ेस जो एक द्विदिश अवरोधक कतार के लिए अतिरिक्त तरीकों का वर्णन करता है। कतार के दोनों किनारों पर डेटा डाला और निकाला जा सकता है।

लिंक्डब्लॉकिंगडीक <ई> - लिंक नोड्स पर द्विदिश अवरोधक कतार, एक ताला के साथ एक सरल द्विदिश सूची के रूप में लागू किया गया। कतार का आकार निर्माता और डिफ़ॉल्ट के माध्यम से Integer.MAX_VALUE को निर्दिष्ट किया गया है।

TransferQueue <E> - यह इंटरफ़ेस उस में दिलचस्प हो सकता है जब एक आइटम को कतार में जोड़ते समय, "निर्माता" को सम्मिलित करने वाले धागे को ब्लॉक करना संभव है जब तक कि एक और धागा "उपभोक्ता" आइटम को कतार से बाहर नहीं खींचता। ताला या तो टाइमआउट के साथ हो सकता है, या यहां तक ​​कि लंबित "उपभोक्ता" के लिए जाँच द्वारा प्रतिस्थापित किया जा सकता है। इस प्रकार, एक संदेश हस्तांतरण तंत्र को सिंक्रोनस और एसिंक्रोनस दोनों संदेशों के समर्थन के साथ लागू करना संभव हो जाता है।

LinkedTransferQueue <E> - स्लैक एल्गोरिथ्म के साथ दोहरी कतार के आधार पर TransferQueue का कार्यान्वयन। जब वे स्टैंडबाय मोड में होते हैं तो सक्रिय रूप से CAS और पार्किंग स्ट्रीम का उपयोग करते हैं।

3. सिंक्रोनाइजर्स

यह खंड थ्रेड को सक्रिय रूप से प्रबंधित करने के लिए कक्षाएं प्रदान करता है।

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

CountDownLatch - एक या अधिक थ्रेड्स को प्रतीक्षा करने की अनुमति देता है जब तक कि निश्चित संख्या में संचालन अन्य थ्रेड्स पर पूरा नहीं हो जाता है। क्लासिक ड्राइवर उदाहरण बहुत अच्छी तरह से वर्ग के तर्क का वर्णन करता है: ड्राइवर को कॉल करने वाला थ्रेड तब तक प्रतीक्षा विधि (या समय-सीमा के बिना) में लटका रहेगा जब तक कि ड्राइवर के साथ थ्रेड प्रारंभ नहीं हो जाता है और फिर काउंटडाउन विधि को कॉल करता है। यह विधि एक-एक करके काउंट डाउन काउंटर को घटाती है। जैसे ही काउंटर शून्य हो जाता है, प्रतीक्षा में सभी प्रतीक्षा थ्रेड काम करना जारी रखेंगे, और बाद के सभी प्रतीक्षा कॉल प्रतीक्षा के बिना जाएंगे। काउंट डाउन काउंटर वन-टाइम है और इसे अपनी मूल स्थिति में रीसेट नहीं किया जा सकता है।

CyclicBarrier - इसका उपयोग किसी बिंदु पर दिए गए थ्रेड की संख्या को सिंक्रनाइज़ करने के लिए किया जा सकता है। एक बाधा तब प्राप्त होती है जब एन-थ्रेड्स प्रतीक्षा (...) विधि और लॉक को कॉल करते हैं। उसके बाद, काउंटर को उसके मूल मूल्य पर रीसेट कर दिया जाता है, और वेटिंग थ्रेड्स को मुक्त कर दिया जाता है। इसके अतिरिक्त, यदि आवश्यक हो, तो थ्रेड को अनलॉक करने और काउंटर को रीसेट करने से पहले एक विशेष कोड चलाना संभव है। ऐसा करने के लिए, रनने योग्य इंटरफ़ेस के कार्यान्वयन के साथ एक ऑब्जेक्ट को कंस्ट्रक्टर के माध्यम से पारित किया जाता है।

एक्सचेंजर <V> - जैसा कि नाम से ही स्पष्ट है, इस वर्ग का मुख्य उद्देश्य दो धाराओं के बीच की वस्तुओं का आदान-प्रदान है। उसी समय, शून्य मान भी समर्थित होते हैं, जो आपको केवल एक ऑब्जेक्ट को स्थानांतरित करने के लिए इस वर्ग का उपयोग करने की अनुमति देता है, या बस दो धाराओं के सिंक्रोनाइज़र के रूप में। एक्सचेंज (...) विधि को कॉल करने वाला पहला थ्रेड तब तक ब्लॉक रहेगा जब तक कि वही विधि दूसरे थ्रेड को कॉल न करे। एक बार ऐसा होने पर, थ्रेड्स मूल्यों का आदान-प्रदान करेंगे और अपना काम जारी रखेंगे।

Phaser - थ्रेड सिंक्रोनाइज़ेशन के लिए बैरियर का बेहतर क्रियान्वयन, जो साइक्लिक बैरियर और काउंटडाउन लच की कार्यक्षमता को जोड़ती है, उनमें से सर्वश्रेष्ठ को शामिल करना। इसलिए, थ्रेड्स की संख्या कठोरता से सेट नहीं है और गतिशील रूप से बदल सकती है। वर्ग को पुन: उपयोग किया जा सकता है और धारा की तत्परता को अवरुद्ध किए बिना रिपोर्ट कर सकता है। अधिक विवरण यहाँ हब्रतोपिका में पाया जा सकता है ।

४.उपहार करने वाले

इसलिए हमें पैकेज का सबसे बड़ा हिस्सा मिला। यहां हम भविष्य के और कॉल करने योग्य इंटरफेस के माध्यम से परिणाम प्राप्त करने की संभावना के साथ अतुल्यकालिक कार्यों को चलाने के लिए इंटरफेस का वर्णन करेंगे, साथ ही थ्रेड पूल बनाने के लिए सेवाओं और कारखानों: थ्रेडपूल एक्सिक्यूटर, शेड्यूल्डपूल एक्ज़ीक्यूटर, फॉरजोन पॉइंट। एक बेहतर समझ के लिए, हम इंटरफेस और कक्षाओं का एक छोटा अपघटन करेंगे।

भविष्य और कॉल करने योग्य

भविष्य <v> - एक अतुल्यकालिक ऑपरेशन के परिणाम प्राप्त करने के लिए एक महान इंटरफ़ेस। यहाँ मुख्य विधि प्राप्त विधि है, जो दूसरे धागे में एसिंक्रोनस ऑपरेशन पूरा होने तक वर्तमान थ्रेड (एक टाइमआउट के साथ या बिना) को ब्लॉक करती है। इसके अलावा, ऑपरेशन रद्द करने और वर्तमान स्थिति की जांच करने के लिए अतिरिक्त तरीके हैं। FutureTask वर्ग को अक्सर कार्यान्वयन के रूप में उपयोग किया जाता है।

RunnableFuture <V> - अगर फ्यूचर क्लाइंट एपीआई के लिए एक इंटरफेस है, तो RunnableFuture इंटरफेस पहले से ही अतुल्यकालिक भाग को चलाने के लिए उपयोग किया जाता है। रन का सफल समापन () विधि एसिंक्रोनस ऑपरेशन को पूरा करता है और प्राप्त विधि के माध्यम से परिणाम खींचने की अनुमति देता है।

कॉल करने योग्य <V> - अतुल्यकालिक संचालन के लिए Runnable इंटरफ़ेस का एक विस्तारित एनालॉग। आपको एक टाइप किए गए मान को वापस करने और चेक किए गए अपवाद को फेंकने की अनुमति देता है। हालाँकि इस इंटरफ़ेस से रन () विधि गायब है, कई java.util.concurrent कक्षाएं रननेबल के साथ इसका समर्थन करती हैं।

FutureTask <V> - भविष्य / RunnableFuture इंटरफ़ेस का कार्यान्वयन। एक अतुल्यकालिक ऑपरेशन को रननेबल या कॉल करने योग्य वस्तुओं के रूप में निर्माणकर्ताओं में से एक के इनपुट पर प्राप्त किया जाता है। FutureTask वर्ग को एक कार्यकर्ता थ्रेड में चलाने के लिए डिज़ाइन किया गया है, उदाहरण के लिए, नए थ्रेड (कार्य) .start (), या थ्रेडपूल एक्ज़ीक्यूटर के माध्यम से। अतुल्यकालिक ऑपरेशन के परिणाम प्राप्त (...) विधि के माध्यम से खींचे जाते हैं।

विलंबित - अतुल्यकालिक कार्यों के लिए उपयोग किया जाता है जो भविष्य में शुरू होना चाहिए, साथ ही साथ DelayQueue में भी। आपको अतुल्यकालिक ऑपरेशन की शुरुआत से पहले समय निर्धारित करने की अनुमति देता है।

शेड्यूल्ड फ़ॉइल <V> - भविष्य और देरी इंटरफेस के संयोजन टोकन इंटरफ़ेस।

RunnableScheduledFuture <V> - एक इंटरफ़ेस जो RunnableFuture और ScheduledFuture को जोड़ता है। इसके अतिरिक्त, आप यह संकेत कर सकते हैं कि क्या कार्य एक बार का कार्य है या यह निर्दिष्ट आवृत्ति पर शुरू किया जाना चाहिए या नहीं।

निष्पादन सेवाएँ

निर्वाहक - कक्षाओं के लिए एक मूल इंटरफ़ेस प्रदान करता है जो रनने योग्य कार्यों के लॉन्च को लागू करता है। यह एक कार्य को जोड़ने और इसे शुरू करने के तरीके के बीच काढ़ा सुनिश्चित करता है।

ExecutorService - एक इंटरफ़ेस जो Runnable या Callable कार्यों को चलाने के लिए एक सेवा का वर्णन करता है।इनपुट सबमिट विधियां कॉल करने योग्य या चलाने योग्य के रूप में एक कार्य को स्वीकार करती हैं, और फ्यूचर का उपयोग रिटर्न वैल्यू के रूप में किया जाता है, जिसके माध्यम से आप परिणाम प्राप्त कर सकते हैं। InvokeAll विधियाँ थ्रेड ब्लॉकिंग के साथ कार्य सूचियों के साथ काम करती हैं जब तक कि हस्तांतरित सूची में सभी कार्य पूर्ण नहीं होते या निर्दिष्ट समय समाप्त होने से पहले। InvokeAny तरीके कॉलिंग थ्रेड को तब तक ब्लॉक करते हैं जब तक कि कोई भी स्थानांतरित कार्य पूरा नहीं हो जाता। सब कुछ के अलावा, इंटरफ़ेस में सुंदर शटडाउन के तरीके हैं। शटडाउन विधि को कॉल करने के बाद, यह सेवा अब कार्यों को स्वीकार नहीं करेगी, सेवा में किसी कार्य को फेंकने की कोशिश करने पर RejectExecutionException को फेंकना।

ScheduledExecutorService - ExecutorService विधियों के अतिरिक्त, यह इंटरफ़ेस लंबित कार्यों को चलाने की क्षमता जोड़ता है।

AbstractExecutorService- ExecutorService के निर्माण के लिए एक अमूर्त वर्ग। कार्यान्वयन में सबमिट, इनवोकएल, इनवोकैनी विधियों का मूल कार्यान्वयन है। ThreadPoolExecutor, ScheduledThreadPoolExecutor, और ForkJoinPool को इस वर्ग से विरासत में मिला है।

ThreadPoolExecutor & Factory

एक्ज़ीक्यूटर्स - थ्रेडपूल एक्ज़ीक्यूटर, शेड्यूल्डड्रेडपूल एक्ज़ीक्यूटर बनाने के लिए फैक्ट्री क्लास। यदि आपको इन पूलों में से एक बनाने की आवश्यकता है, तो यह कारखाना वास्तव में आपकी आवश्यकता है। इसके अलावा, इसमें विभिन्न Runnable-Callable, PrivilegedAction-Callable, PrivilegedExceptionAction-Callable एडेप्टर और अन्य शामिल हैं।

ThreadPoolExecutor- एक बहुत शक्तिशाली और महत्वपूर्ण वर्ग। थ्रेड पूल में अतुल्यकालिक कार्यों को चलाने के लिए उपयोग किया जाता है। इस प्रकार, प्रवाह को बढ़ाने और रोकने के लिए ओवरहेड लगभग पूरी तरह से अनुपस्थित है। और पूल में निश्चित अधिकतम थ्रेड्स के कारण, अनुमानित अनुप्रयोग प्रदर्शन प्रदान किया जाता है। जैसा कि पहले उल्लेख किया गया है, यह एक्ज़ेक्यूटर्स फ़ैक्टरी विधियों में से एक के माध्यम से इस पूल को बनाना बेहतर है। यदि मानक कॉन्फ़िगरेशन पर्याप्त नहीं हैं, तो डिजाइनरों या बसने वालों के माध्यम से आप पूल के सभी बुनियादी मापदंडों को सेट कर सकते हैं। इस विषय में अधिक जानकारी प्राप्त की जा सकती है ।

ScheduledThreadPoolExecutor - ThreadPoolExecutor विधियों के अलावा, यह आपको एक निश्चित विलंब के साथ-साथ कुछ अंतरालों पर कार्य शुरू करने की अनुमति देता है, जो आपको इस वर्ग के आधार पर टाइमर सेवा को लागू करने की अनुमति देता है।

थ्रेडफैक्ट्री - डिफ़ॉल्ट रूप से, थ्रेडपूल एक्सक्यूटर एक्सेकॉर्स के माध्यम से प्राप्त मानक थ्रेड फैक्ट्री का उपयोग करता है। यदि आपको कुछ और चाहिए, उदाहरण के लिए, प्राथमिकता या थ्रेड नाम सेट करना, तो आप इस इंटरफ़ेस के कार्यान्वयन के साथ एक क्लास बना सकते हैं और इसे थ्रेडपूल एक्सक्यूटर के पास भेज सकते हैं।

RejectedExecutionHandler- आपको किसी ऐसे कार्य के लिए हैंडलर को परिभाषित करने की अनुमति देता है जो किसी कारणवश थ्रेडपूल एक्ज़ीक्यूटर के माध्यम से नहीं किया जा सकता है। ऐसा कोई मामला हो सकता है जब कोई मुफ्त थ्रेड्स न हों या सेवा बंद हो या बंद हो। कई मानक कार्यान्वयन थ्रेडपूल एक्ज़ीक्यूटर क्लास में हैं: CallerRunsPolicy - कॉलिंग थ्रेड में कार्य शुरू करता है; AbortPolicy - स्वीकृति को फेंकता है; त्यागपत्र - कार्य को अनदेखा करता है; DiscardOldestPolicy - कतार से सबसे पुराना गैर-चलने वाला कार्य निकालता है, फिर एक नया कार्य जोड़ने का प्रयास करता है।

कांटा शामिल हो

जावा 1.7 में, पुनरावर्ती कार्यों को हल करने के लिए एक नया फोर्क ज्वाइन फ्रेमवर्क पेश किया गया है जो एल्गोरिदम या मैप रिड्यूस को विभाजित करने और जीतने का काम करता है । इसे स्पष्ट करने के लिए, आप क्विकसर्ट सॉर्टिंग एल्गोरिदम का एक दृश्य उदाहरण दे सकते हैं: इसलिए, भागों में विभाजित करके, आप विभिन्न थ्रेड्स में उनके समानांतर प्रसंस्करण को प्राप्त कर सकते हैं। इस समस्या को हल करने के लिए, आप सामान्य थ्रेडपूल एक्ज़ीक्यूटर का उपयोग कर सकते हैं, लेकिन संदर्भ के बार-बार स्विच करने और निष्पादन नियंत्रण की निगरानी के कारण, यह सब बहुत प्रभावी ढंग से काम नहीं करता है। यह वह जगह है जहां फोर्क जॉइन फ्रेमवर्क एक काम-चोरी एल्गोरिथ्म के आधार पर बचाव के लिए आता है । यह बड़ी संख्या में प्रोसेसरों के साथ सिस्टम में खुद को सबसे अच्छा दिखाता है। अधिक जानकारी यहाँ ब्लॉग पर पाया जा सकता है।

या डौग ली प्रकाशन । आप यहां प्रदर्शन और मापनीयता के बारे में पढ़ सकते हैं ।

ForkJoinPool - रूट (मुख्य) ForkJoinTask कार्यों को शुरू करने के लिए प्रवेश बिंदु का प्रतिनिधित्व करता है। सबटैक कार्य के तरीकों के माध्यम से लॉन्च किया जाता है जिसमें से आपको शूट (कांटा) की आवश्यकता होती है। डिफ़ॉल्ट रूप से, जेवीएम के लिए उपलब्ध कोर की संख्या के बराबर थ्रेड्स की संख्या के साथ एक थ्रेड पूल बनाया जाता है।

ForkJoinTask- सभी फोर्क में शामिल कार्यों के लिए बेस क्लास। मुख्य विधियों में शामिल हैं: कांटा () - एसिंक्रोनस निष्पादन के लिए वर्तमान ForkJoinWorkerThread थ्रेड की कतार में एक कार्य जोड़ता है; invoke () - वर्तमान थ्रेड में एक कार्य लॉन्च करता है; join () - परिणाम की वापसी के साथ उपमा के पूरा होने का इंतजार करता है; invokeAll (...) - सभी तीन पिछले पिछले ऑपरेशनों को जोड़ती है, एक बार में दो या दो से अधिक कार्य करता है; अनुकूलन (...) - रननेबल या कॉल करने योग्य वस्तुओं से एक नया ForkJoinTask कार्य बनाता है।

RecursiveTask - गणना विधि की घोषणा के साथ ForkJoinTask से एक सार वर्ग, जिसमें वारिस में अतुल्यकालिक ऑपरेशन किया जाना चाहिए।

RecursiveAction - इस स्थिति में RecursiveTask से मुश्किल यह परिणाम नहीं देता है।

ForkJoinWorkerThread- ForkJoinPoll में डिफ़ॉल्ट कार्यान्वयन के रूप में उपयोग किया जाता है। यदि वांछित है, तो आप वर्कर थ्रेड के आरंभ और पूर्ण होने के तरीकों को विरासत और अधिभार कर सकते हैं।

पूर्ण सेवा

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

ExecutorCompletionService - अनिवार्य रूप से किसी भी वर्ग पर एक आवरण है जो Executor इंटरफ़ेस को लागू करता है, जैसे कि ThreadPoolExecutor या ForkJoinPool। यह मुख्य रूप से तब उपयोग किया जाता है जब आप कार्य शुरू करने के तरीके से अमूर्त करना चाहते हैं और उनके निष्पादन को नियंत्रित करते हैं। यदि पूर्ण कार्य हैं - तो उन्हें बाहर निकालें, यदि नहीं - कुछ खत्म होने तक प्रतीक्षा करें। डिफ़ॉल्ट सेवा लिंक्डब्लॉकिंग क्यू पर आधारित है, लेकिन किसी भी अन्य ब्लॉकिंगक्यू को लागू किया जा सकता है।

5. ताले

शर्त - एक इंटरफ़ेस जो मानक प्रतीक्षा / अधिसूचित / सूचना के साथ वैकल्पिक तरीकों का वर्णन करता है। एक शर्त के साथ एक वस्तु को ज्यादातर ताले से लॉक.न्यूकॉन्डिशन () विधि के माध्यम से प्राप्त किया जाता है। इस प्रकार, आप एक वस्तु के लिए प्रतीक्षा / सूचना के कई सेट प्राप्त कर सकते हैं।

लॉक - लॉक ढांचे से मूल इंटरफ़ेस, जो सिंक्रनाइज़ेशन का उपयोग करते समय संसाधनों / ब्लॉकों तक पहुंच को प्रतिबंधित करने के लिए अधिक लचीला दृष्टिकोण प्रदान करता है। इसलिए, कई तालों का उपयोग करते समय, उनकी रिहाई का क्रम मनमाना हो सकता है। इसके अलावा एक वैकल्पिक परिदृश्य का पालन करने का अवसर है, अगर ताला पहले से ही किसी द्वारा कब्जा कर लिया गया है।

ReentrantLock- प्रवेश पर ताला। केवल एक धागा संरक्षित ब्लॉक में प्रवेश कर सकता है। वर्ग निष्पक्ष और गैर-निष्पक्ष थ्रेड अनलॉकिंग का समर्थन करता है। "ईमानदार" अनलॉक के साथ, ऑर्डर जिसमें थ्रेड्स कॉल लॉक () जारी किए जाते हैं, का सम्मान किया जाता है। "अनुचित" अनलॉक करने के साथ, थ्रेड रिलीज के आदेश की गारंटी नहीं है, लेकिन, एक बोनस के रूप में, ऐसे अनलॉकिंग तेजी से काम करते हैं। डिफ़ॉल्ट रूप से, "अनुचित" अनलॉकिंग का उपयोग किया जाता है।

ReadWriteLock - ताले पढ़ने / लिखने के लिए एक अतिरिक्त इंटरफ़ेस। इस तरह के ताले बेहद उपयोगी होते हैं जब सिस्टम में कई रीड ऑपरेशंस और कुछ राइट ऑपरेशन होते हैं।

ReentrantReadWriteLock- यह बहुत बार बहुस्तरीय सेवाओं और कैश में उपयोग किया जाता है, जो सिंक्रनाइज़ किए गए ब्लॉक की तुलना में बहुत अच्छा प्रदर्शन हासिल करता है। वास्तव में, वर्ग 2 परस्पर अनन्य मोड में संचालित होता है: कई पाठक समानांतर में डेटा पढ़ते हैं और जब केवल 1 लेखक डेटा लिखता है।

ReentrantReadWriteLock.ReadLock - पाठकों के लिए लॉक पढ़ें, readWriteLock.readLock () के माध्यम से प्राप्त किया।

ReentrantReadWriteLock.WriteLock - readWriteLock.writeLock () के माध्यम से प्राप्त लेखकों के लिए लॉक लिखें।

LockSupport - ताले के साथ निर्माण कक्षाओं के लिए डिज़ाइन किया गया। अप्रचलित Thread.suspend () और Thread.resume () विधियों के बजाय पार्किंग थ्रेड्स के लिए विधियाँ शामिल हैं।



AbstractOwnableSynchronizer- तुल्यकालन तंत्र के निर्माण के लिए आधार वर्ग। इसमें एक विशेष स्ट्रीम को संग्रहीत करने और पढ़ने के लिए केवल एक गेट्टर / सेटर जोड़ी होती है जो डेटा के साथ काम कर सकती है।

AbstractQueuedSynchronizer - FutureTask, CountDownLatch, Semaphore, ReentrantLock, ReentrantReadWriteLock में सिंक्रोनाइज़ेशन तंत्र के लिए बेस क्लास के रूप में उपयोग किया जाता है। इसका उपयोग नए तुल्यकालन तंत्र बनाने के लिए किया जा सकता है जो एक एकल और परमाणु अंतर मूल्य पर भरोसा करते हैं।

AbstractQueuedLongSynchronizer - AbstractQueuedSynchronizer का एक रूपांतर जो लंबे समय के परमाणु मूल्य का समर्थन करता है।

6. एटिक्स

AtomicBoolean , AtomicInteger , AtomicLong , AtomicIntegerArray , AtomicLongArray - क्या होगा यदि वर्ग को एक सरल अंतर चर तक पहुंच को सिंक्रनाइज़ करने की आवश्यकता है? आप कंस्ट्रक्शन का उपयोग सिंक्रनाइज़ के साथ कर सकते हैं, और जब परमाणु संचालन सेट / प्राप्त करते हैं, तो वाष्पशील भी उपयुक्त है। लेकिन आप नए परमाणु * वर्गों का उपयोग करके और भी बेहतर कर सकते हैं। CAS के उपयोग के कारण , इन वर्गों के साथ संचालन तेजी से होता है अगर सिंक्रनाइज़ / अस्थिर के माध्यम से किया जाता है। साथ ही, किसी दिए गए मूल्य के साथ-साथ परमाणु वृद्धि के लिए तरीके भी हैं, साथ ही वेतन वृद्धि / गिरावट भी है।

AtomicReference - एक ऑब्जेक्ट के संदर्भ में परमाणु संचालन के लिए एक वर्ग।

AtomicMarkableReference - निम्न युग्म क्षेत्रों के साथ परमाणु संचालन के लिए एक वर्ग: ऑब्जेक्ट संदर्भ और बिट फ्लैग (सही / गलत)।

AtomicStampedReference - निम्न युग्म क्षेत्रों के साथ परमाणु संचालन के लिए एक वर्ग: ऑब्जेक्ट संदर्भ और इंट वैल्यू।

AtomicReferenceArray - वस्तु संदर्भों की एक सरणी जिसे परमाणु अद्यतन किया जा सकता है।

AtomicIntegerFieldUpdater , AtomicLongFieldUpdater , AtomicReferenceFieldUpdater - परावर्तन के माध्यम से उनके नाम से परमाणु अद्यतन क्षेत्रों के लिए कक्षाएं। कैस के लिए फ़ील्ड ऑफ़सेट को कंस्ट्रक्टर और कैश्ड, इन्क्ल में निर्धारित किया जाता है। प्रतिबिंब के कारण प्रदर्शन में कोई मजबूत गिरावट नहीं है।

एक निष्कर्ष के बजाय

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