जावा कतार इंटरफ़ेस और इसके कार्यान्वयन

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

कतार डेटा संरचना

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

जावा में कतार

जावा में कतार एक इंटरफ़ेस है। Oracle प्रलेखन के अनुसार, कतार इंटरफ़ेस में 2 सुपरइंटरफेस, 4 अलग-अलग इंटरफ़ेस हैं जो कतार से प्राप्त होते हैं, और कक्षाओं की एक अत्यंत प्रभावशाली सूची है। इसका मतलब क्या है? सबसे पहले, Java Queue Collection Framework का एक हिस्सा है और Collection इंटरफ़ेस को लागू करता है। तो यह संग्रह इंटरफ़ेस के सभी तरीकों जैसे सम्मिलन, विलोपन आदि का समर्थन करता है। Queue Iterable इंटरफ़ेस को लागू करता है, जो किसी वस्तु को "प्रत्येक लूप के लिए" कथन का लक्ष्य बनाने की अनुमति देता है।

कतार के तरीके Java

कतार कई तरीकों की घोषणा करती है। इंटरफ़ेस के तरीकों के रूप में उन्हें कतार को लागू करने वाले सभी वर्गों में प्रदर्शित किया जाना चाहिए। सबसे महत्वपूर्ण कतार विधियाँ, जावा:

• बूलियन ऑफ़र () - यदि संभव हो तो कतार में एक नया तत्व सम्मिलित करता है
• बूलियन ऐड (ई ई) - यदि संभव हो तो कतार में एक नया तत्व सम्मिलित करता है। सफलता के मामले में सही रिटर्न देता है और यदि कोई स्थान नहीं है तो एक IllegalStateException फेंकता है।
• ऑब्जेक्ट पोल () - के सिर से एक तत्व को पुनः प्राप्त करता है और हटाता है। कतार खाली होने पर शून्य वापस आ जाता है।
• ऑब्जेक्ट रिमूव () - कतार के प्रमुख से एक तत्व को पुनः प्राप्त करता है और हटाता है।
• ऑब्जेक्ट पीक () - कतार के प्रमुख से एक तत्व को पुनर्प्राप्त करता है, लेकिन किसी तत्व को नहीं हटाता है। कतार खाली होने पर शून्य वापस आ जाता है।
• वस्तु तत्व () - कतार के प्रमुख से एक तत्व को पुनर्प्राप्त करता है, लेकिन हटाता नहीं है।

जावा कतार के सबइंटरफेस

कतार इंटरफ़ेस 4 सबइंटरफेस द्वारा विरासत में मिला है - BlockingDeque<E>, BlockingQueue<E>, Deque<E>, TransferQueue<E> । आप उन्हें 3 समूहों में विभाजित कर सकते हैं: Deques, Blocking Queues और Transfer Queues with BlockingDeque पहले दो से संबंधित हैं। आइए इन समूहों पर एक नज़र डालें।

डेक

Deque का अर्थ है D डबल- E nded Q ueue और एक क्यू (फ़र्स्ट-इन-फ़र्स्ट-आउट/FIFO) के रूप में डेटा के किसी भी टेल से जोड़ने या हटाने का समर्थन करता है या सिर से एक अन्य लोकप्रिय डेटा संरचना के रूप में जिसे स्टैक (लास्ट-इन-इन) कहा जाता है फर्स्ट-आउट/एलआईएफओ)। Deque इंटरफ़ेस लागू करने वाली कक्षाएं: ArrayDeque, ConcurrentLinkedDeque, LinkedBlockingDeque, LinkedList।

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

एक अवरुद्ध कतार एक कतार है जो दो मामलों में धागे को अवरुद्ध करती है:

• थ्रेड खाली कतार से तत्व प्राप्त करने का प्रयास कर रहा है
• थ्रेड तत्वों को पूर्ण कतार में रखने का प्रयास कर रहा है

जब कोई थ्रेड खाली कतार से आइटम प्राप्त करने का प्रयास करता है, तो वह तब तक प्रतीक्षा करता है जब तक कोई अन्य थ्रेड आइटम को कतार में नहीं रखता। इसी तरह, जब कोई धागा तत्वों को एक पूर्ण कतार में रखने की कोशिश करता है, तो यह तब तक प्रतीक्षा करता है जब तक कि कोई अन्य धागा तत्वों को मुक्त स्थान प्राप्त करने के लिए कतार से बाहर नहीं ले जाता। ज़रूर, "पूर्ण कतार" की अवधारणा का अर्थ है कि कतार का एक सीमित आकार है, जो आमतौर पर कंस्ट्रक्टर में निर्दिष्ट होता है। मानक ब्लॉकिंग कतारों में लिंक्डब्लॉकिंग क्यू, सिंक्रोनस क्यू और ऐरेब्लॉकिंग क्यू शामिल हैं। BlockingQueue इंटरफ़ेस की कार्यान्वयन कक्षाएं : ArrayBlockingQueue, DelayQueue, LinkedBlockingDeque, LinkedBlockingQueue, LinkedTransferQueue, प्रायोरिटीब्लॉकिंग क्यू, सिंक्रोनस क्यू। ब्लॉकिंगडेकBlockingQueue के लिए एक उप-इंटरफ़ेस है। BlockingDeque जैसे BlockingQueue एक अवरुद्ध कतार है, लेकिन द्विदिश है। तो यह Deque इंटरफ़ेस के गुणों को इनहेरिट करता है। यह बहु-थ्रेडेड निष्पादन के लिए उन्मुख है, शून्य तत्वों की अनुमति नहीं देता है और क्षमता सीमित हो सकती है। BlockingDeque इंटरफ़ेस का कार्यान्वयन कतार के खाली होने पर तत्वों को प्राप्त करने के संचालन को अवरुद्ध करता है, और यदि यह भरा हुआ है तो कतार में एक तत्व जोड़ना।

स्थानांतरण कतारें

TransferQueue इंटरफ़ेस BlockingQueue इंटरफ़ेस का विस्तार करता है। हालाँकि BlockingQueue इंटरफ़ेस कतारों के कार्यान्वयन के विपरीत, जहाँ कतार के खाली होने (पढ़ने) या कतार के पूर्ण (लेखन) होने पर थ्रेड्स को ब्लॉक किया जा सकता है, TransferQueue इंटरफ़ेस कतारें राइट स्ट्रीम को तब तक ब्लॉक कर देती हैं जब तक कि कोई अन्य स्ट्रीम तत्व को पुनः प्राप्त नहीं कर लेती। इसके लिए स्थानांतरण विधि का प्रयोग करें। दूसरे शब्दों में, BlockingQueue का कार्यान्वयन गारंटी देता है कि निर्माता द्वारा बनाया गया तत्व कतार में होना चाहिए, जबकि TransferQueue का कार्यान्वयन गारंटी देता है कि निर्माता तत्व उपभोक्ता द्वारा "प्राप्त" किया गया है। TransferQueue इंटरफ़ेस का केवल एक आधिकारिक Java कार्यान्वयन है - LinkedTransferQueue।

जावा कतार कार्यान्वयन

कई वर्ग हैं जो क्यू इंटरफ़ेस को लागू करते हैं:

• सार कतार जावा 8 दस्तावेज़ों के अनुसार, यह सार वर्ग कुछ कतार संचालन के बुनियादी कार्यान्वयन प्रदान करता है। यह अशक्त तत्वों की अनुमति नहीं देता है। कतार क्लासिकल ऑफ़र , पोल और पीक के आधार पर क्रमशः 3 और विधियाँ जोड़ें, निकालें और तत्व हैं। हालांकि वे झूठे या अशक्त रिटर्न के माध्यम से विफलता का संकेत देने के बजाय अपवाद फेंक देते हैं।
• ArrayBlockingQueue - एक सरणी द्वारा समर्थित एक निश्चित आकार फीफो अवरुद्ध कतार
• ArrayDeque — Deque इंटरफ़ेस का आकार बदलने योग्य सरणी कार्यान्वयन
• ConcurrentLinkedDeque — लिंक किए गए नोड्स पर आधारित एक असीमित समवर्ती डेक।
• ConcurrentLinkedQueue - लिंक किए गए नोड्स पर आधारित एक असीमित थ्रेड-सुरक्षित कतार।
• DelayQueue - ढेर द्वारा समर्थित एक समय-आधारित शेड्यूलिंग कतार
• LinkedBlockingDeque — Deque इंटरफ़ेस का समवर्ती कार्यान्वयन।
• LinkedBlockingQueue - लिंक किए गए नोड्स द्वारा समर्थित एक वैकल्पिक रूप से बाध्य FIFO अवरोधक कतार
• लिंक्डलिस्ट - सूची और डीक्यू इंटरफेस की दोगुनी-लिंक्ड सूची कार्यान्वयन। सभी वैकल्पिक सूची संचालन लागू करता है, और सभी तत्वों की अनुमति देता है (शून्य सहित)
• LinkedTransferQueue - लिंक किए गए नोड्स पर आधारित एक असीमित TransferQueue
• प्रायोरिटीब्लॉकिंगक्यू - ढेर द्वारा समर्थित एक असीमित ब्लॉकिंग प्राथमिकता कतार
• प्रायोरिटी क्यू - ढेर डेटा संरचना के आधार पर एक प्राथमिकता कतार
• SynchronousQueue - एक ब्लॉकिंग कतार जहां प्रत्येक इंसर्ट ऑपरेशन को दूसरे थ्रेड द्वारा संबंधित रिमूव ऑपरेशन के लिए इंतजार करना चाहिए, और इसके विपरीत।

सबसे लोकप्रिय कार्यान्वयन लिंक्डलिस्ट, ऐरेब्लॉकिंग क्यू और प्रायोरिटी क्यू हैं। आइए उन्हें देखें और बेहतर समझ के लिए कुछ उदाहरण करें।

लिंक्ड सूची

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

लिंक्डलिस्ट कंस्ट्रक्टर्स

LinkedList() पैरामीटर के बिना खाली सूची बनाने के लिए उपयोग किया जाता है। LinkedList(Collection<? extends E> c) निर्दिष्ट संग्रह के तत्वों वाली एक सूची बनाने के लिए है, क्रम में, वे संग्रह के पुनरावर्तक द्वारा लौटाए जाते हैं।

मुख्य लिंक्डलिस्ट तरीके:

• जोड़ें (ई तत्व) इस सूची के अंत में निर्दिष्ट तत्व जोड़ता है;
• जोड़ें (इंट इंडेक्स, ई तत्व) तत्व को निर्दिष्ट स्थिति सूचकांक में सम्मिलित करता है;
• get(int index) इस सूची में निर्दिष्ट स्थान पर तत्व लौटाता है;
• हटाएं (इंट इंडेक्स) उस तत्व को हटा दें जो स्थिति सूचकांक पर है;
• हटाएं (ऑब्जेक्ट ओ) इस सूची से ?ओ तत्व की पहली घटना को हटा देता है यदि यह वहां है।
• हटाएं() सूची के पहले तत्व को पुनर्प्राप्त और हटा देता है।
• AddFirst (), AddLast () सूची के आरंभ/अंत में एक तत्व जोड़ें
• स्पष्ट() सूची से सभी तत्वों को हटा देता है
• सम्‍मिलित है (ऑब्जेक्ट ओ) सच है अगर सूची में ओ तत्व है।
• indexOf(Object o) o तत्व की पहली घटना का सूचकांक लौटाता है, या -1 यदि यह सूची में नहीं है।
• सेट (इंट इंडेक्स, ई एलिमेंट) तत्व को इंडेक्स स्थिति में तत्व के साथ बदल देता है
• आकार () सूची में तत्वों की मात्रा लौटाता है।
• toArray() एक सरणी देता है जिसमें सभी सूची के तत्व पहले से अंतिम तत्व तक होते हैं।
• पॉप () जो स्टैक से एक तत्व को पॉप करता है (सूची द्वारा दर्शाया गया है)
• पुश (ई ई) जो एक तत्व को स्टैक पर धकेलता है (इस सूची द्वारा दर्शाया गया है)

जावा कतार उदाहरण - लिंक्डलिस्ट (तत्वों को अलग-अलग तरीकों से डालना और निकालना)

import java.util.*;
 
public class LinkedListTest {
 
       public static void main(String args[]){
 
           LinkedList<Integer> myLinkedList= new LinkedList<Integer>();
           myLinkedList.add(1);
           myLinkedList.add(2);
           myLinkedList.add(4);
           System.out.println("three added elements: " + myLinkedList);
           //put one element into the head, not to the tail:
           myLinkedList.push(5);
           System.out.println("The new element last in will be the first: " + myLinkedList);
           //add new element at the specified position:
           myLinkedList.add(4,3);
           //put one element into the head, not to the tail (same as push):
           myLinkedList.addFirst(6);
           System.out.println(myLinkedList);
           //now remove element no 2 (it is 1):
           myLinkedList.remove(2);
           System.out.println(myLinkedList);
           //now remove the head of the list
           myLinkedList.pop();
           System.out.println(myLinkedList);
           //remove with the other method
           myLinkedList.remove();
           System.out.println(myLinkedList);
           //and with one more
           myLinkedList.poll();
           System.out.println(myLinkedList);
       }
       }

प्राथमिकता कतार

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

मुख्य प्राथमिकता कतार विधियाँ:

• बूलियन ऐड (ऑब्जेक्ट) निर्दिष्ट तत्व को प्राथमिकता कतार में सम्मिलित करता है। सफलता के मामले में सच हो जाता है। यदि कतार भरी हुई है, तो विधि एक अपवाद को फेंक देती है।
• बूलियन प्रस्ताव (ऑब्जेक्ट) निर्दिष्ट तत्व को इस प्राथमिकता कतार में सम्मिलित करता है। यदि कतार भरी हुई है, तो विधि झूठी हो जाती है।
• बूलियन रिमूव (ऑब्जेक्ट) इस कतार से निर्दिष्ट तत्व का एक उदाहरण निकालता है, यदि यह मौजूद है।
• ऑब्जेक्ट पोल () इस कतार के प्रमुख को पुनः प्राप्त करता है और हटाता है। कतार खाली होने पर शून्य वापस आ जाता है।
• शून्य स्पष्ट () प्राथमिकता कतार से सभी तत्वों को हटा देता है।
• ऑब्जेक्ट एलिमेंट () इस कतार के प्रमुख को हटाए बिना प्राप्त करता है। कतार खाली होने पर NoSuchElementException को फेंकता है।
• ऑब्जेक्ट पीक () कतार के प्रमुख को हटाए बिना पुनर्प्राप्त करता है। कतार खाली होने पर शून्य वापस आ जाता है।
• बूलियन सम्‍मिलित (ऑब्‍जेक्‍ट ओ) सच लौटाता है यदि क्‍यू में ओ तत्‍व है।
• int size() इस कतार में तत्वों की संख्या लौटाता है।

प्राथमिकता कतार का उदाहरण

import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
 
public class PriorityQueueExample {
   public static void main(String[] args) {
 
       Queue<Integer> queueL = new LinkedList<>();
       for (int i = 5; i > 0; i--) {
           queueL.add(i);
       }
       System.out.println("Print our LinkedList Queue (FIFO): " + queueL);
       Queue<Integer> priorityQueue = new PriorityQueue<>();
 
       for (int i = 5; i > 0; i--) {
       priorityQueue.offer(i);
       }
 
       System.out.println("PriorityQueue printing (by iterating, no elements removing): " + priorityQueue);
       System.out.println("Print PriorityQueue using poll() (by retrieval): " );
       while (!priorityQueue.isEmpty()) {
           System.out.println(priorityQueue.poll());
       }
}
}
Print our LinkedList Queue (FIFO): [5, 4, 3, 2, 1]
PriorityQueue printing (by iterating, no elements removing): [1, 2, 4, 5, 3]
Print our  PriorityQueue using poll() (by retrieval): 
1
2
3
4
5

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

ऐरेब्लॉकिंग क्यू

ArrayBlockingQueue की आंतरिक डेटा संरचनातत्वों को संग्रहीत करने के लिए एक गोलाकार सरणी पर आधारित है। कतार के अंत में नए तत्व डाले जाने की स्थिति में यह एक विशिष्ट कतार (FIFO) है, और निष्कर्षण संचालन कतार के प्रमुख से एक तत्व लौटाता है। एक बार निर्मित कतार की क्षमता को बदला नहीं जा सकता है। प्रवाह को अवरुद्ध करने के लिए एक पूर्ण कतार में एक तत्व डालने (डालने) का प्रयास; एक खाली कतार से एक तत्व लेने की कोशिश भी थ्रेड को ब्लॉक कर देती है। जैसा कि हमने पहले कहा, यह सरणी गोलाकार है। इसका मतलब है कि सरणी के पहले और अंतिम तत्वों को तार्किक रूप से आसन्न माना जाता है। हर बार जब आप एलिमेंटो को कतार में रखते हैं या कतार से हटाते हैं, तो कतार हेड और टेल तत्वों के सूचकांक को आगे बढ़ाती है। यदि कोई अनुक्रमणिका सरणी के अंतिम तत्व को आगे बढ़ाती है, तो वह 0 से पुनः आरंभ होता है। इसलिए, सिर हटाने (सामान्य सरणी में) के मामले में कतार को सभी तत्वों को स्थानांतरित करने की आवश्यकता नहीं है। हालांकि, मध्य से एक तत्व को हटाने के मामले में (Iterator.remove का उपयोग करके), तत्वों को स्थानांतरित कर दिया जाता है। ArrayBlockingQueue उत्पादकों (तत्वों को सम्मिलित करने) और उपभोक्ताओं (तत्वों को निकालने) के प्रतीक्षा प्रवाह के कार्य को आदेश देने के लिए निर्माता में उचित पैरामीटर के साथ एक अतिरिक्त निष्पक्षता नीति का समर्थन करता है । डिफ़ॉल्ट रूप से, आदेश की गारंटी नहीं है। हालाँकि यदि कतार "निष्पक्ष == सत्य" के साथ बनाई गई है, तो ArrayBlockingQueue वर्ग का कार्यान्वयन FIFO क्रम में थ्रेड एक्सेस प्रदान करता है। इक्विटी आम तौर पर बैंडविड्थ को कम करती है, लेकिन अस्थिरता को भी कम करती है और संसाधनों से बाहर निकलने से रोकती है।

ArrayBlockingQueue क्लास कंस्ट्रक्टर्स

• ArrayBlockingQueue (पूर्णांक क्षमता) निश्चित क्षमता की एक कतार बनाता है और एक डिफ़ॉल्ट पहुँच नीति के साथ।
• ArrayBlockingQueue (पूर्णांक क्षमता, बूलियन फेयर) एक निश्चित क्षमता और निर्दिष्ट पहुँच नीति के साथ एक कतार बनाता है।
• ArrayBlockingQueue (इंट कैपेसिटी, बूलियन फेयर, कलेक्शन <? ई> सी बढ़ाता है) एक्सेस पॉलिसी द्वारा निर्दिष्ट एक निश्चित क्षमता के साथ एक क्यू बनाता है और क्यू में तत्वों को शामिल करता है।

यहाँ हमें BlockingQueueExample उदाहरण मिला है। हम एक तत्व की क्षमता और एक उचित ध्वज के साथ ArrayBlockingQueue की कतार बनाते हैं। दो धागे शुरू हो गए हैं। उनमें से पहला, प्रोड्यूसर थ्रेड, पुट विधि का उपयोग करके संदेश सरणी से संदेशों को कतारबद्ध करता है। दूसरा, उपभोक्ता, थ्रेड कतार से तत्वों को टेक विधि का उपयोग करके पढ़ता है और उन्हें कंसोल में प्रदर्शित करता है। कतार के लिए तत्वों का क्रम स्वाभाविक है।

import java.util.concurrent.*;
 
public class ArrayBlockingQueueExample {
 
   private BlockingQueue<Integer> blockingQueue;
   private final Integer[]  myArray = {1,2,3,4,5};
  
       public ArrayBlockingQueueExample ()
       { blockingQueue = new ArrayBlockingQueue<Integer>(1, true);
           (new Thread(new Producer())).start();
           (new Thread(new Consumer())).start();
       }
 
       class Producer implements Runnable
       {
           public void run() {
               try {
                   int counter = 0;
                   for (int i=0; i < myArray.length; i++) {
                       blockingQueue.put(myArray[i]);
                       if (counter++ < 2)
                           Thread.sleep(3000);
                   } blockingQueue.put(-1);
               }
               catch (InterruptedException e) {
                   System.err.println(e.getMessage());
               }
           }
       }
 
       class Consumer implements Runnable
       {
           public void run() {
               try {
                   Integer message = 0;
                   while (!((message = blockingQueue.take()).equals(-1)))
                       System.out.println(message);
               } catch (InterruptedException e) {
                   System.err.println(e.getMessage());
               }
           }
       }
 
       public static void main(String[] args) {
           new ArrayBlockingQueueExample();
       }
   }

आउटपुट प्राकृतिक क्रम में कतार है; पहले दो तत्व देरी से दिखाई देते हैं। आपने जो सीखा है उसे सुदृढ़ करने के लिए, हमारा सुझाव है कि आप हमारे जावा कोर्स से एक वीडियो सबक देखें

निष्कर्ष

• कतार के अंत में तत्वों को सम्मिलित करने के लिए कतार का उपयोग किया जाता है और कतार की शुरुआत से हटा दिया जाता है। यह फीफो अवधारणा का अनुसरण करता है।
• Java Queue Collection Framework का एक हिस्सा है और Collection इंटरफ़ेस को लागू करता है। तो यह संग्रह इंटरफ़ेस के सभी तरीकों जैसे सम्मिलन, विलोपन आदि का समर्थन करता है।
• कतार के सबसे अधिक उपयोग किए जाने वाले कार्यान्वयन लिंक्डलिस्ट, ऐरेब्लॉकिंग क्यू और प्रायोरिटी क्यू हैं।
• प्राथमिकता कतार के तत्वों को उनके प्राकृतिक क्रम के अनुसार, या कतार निर्माण के समय प्रदान किए गए एक तुलनित्र द्वारा क्रमबद्ध किया जाता है, जिसके आधार पर निर्माणकर्ता का उपयोग किया जाता है।
• यदि BlockingQueues पर कोई अशक्त ऑपरेशन किया जाता है, तो NullPointerException को फेंक दिया जाता है।