जावा रांग इंटरफेस आणि त्याची अंमलबजावणी

येथे आपण Java Queue इंटरफेसची चर्चा करणार आहोत. रांग डेटा स्ट्रक्चर काय आहे, ते Java मध्ये कसे दर्शविले जाते, सर्व रांगांसाठी कोणत्या पद्धती सर्वात महत्त्वाच्या आहेत हे तुम्हाला कळेल . तसेच, जावा भाषेत रांगेची कोणती अंमलबजावणी आहे. त्यानंतर, आम्ही सर्वात महत्वाची अंमलबजावणी जवळून पाहतो आणि उदाहरणांसह त्यांना शिकतो.

रांग डेटा संरचना

रांग ही एक रेखीय अमूर्त डेटा रचना आहे ज्यामध्ये ऑपरेशन्सचा विशिष्ट क्रम असतो — फर्स्ट इन फर्स्ट आउट (FIFO). याचा अर्थ तुम्ही घटक जोडू शकता (किंवा एनक्यू, रांगेत ठेवा) फक्त स्ट्रक्चरच्या शेवटी, आणि एक घटक (रेखा किंवा रांगेतून काढून टाका) फक्त त्याच्या सुरुवातीपासूनच घेऊ शकता. तुम्ही रांग डेटा संरचनेची अगदी सहज कल्पना करू शकता. वास्तविक जीवनात ग्राहकांची रांग किंवा ओळ दिसते. जो ग्राहक प्रथम आला, त्यालाही प्रथम सेवा दिली जाणार आहे. जर तुमच्याकडे मॅकडोनाल्ड्स किंवा इतरत्र चार लोक रांगेत असतील तर, दुकानात येणारा पहिला असेल. नवीन ग्राहक आल्यास, हॅम्बर्गर मिळवण्यासाठी तो/ती 5वा असेल. तर, रांगेत काम करताना, शेवटी नवीन घटक जोडले जातात आणि जर तुम्हाला एखादे घटक मिळवायचे असतील तर ते सुरुवातीपासून घेतले जातील. हे शास्त्रीय रांग डेटा संरचना काम मुख्य तत्त्व आहे.

जावा मध्ये रांग

Java मधील रांग एक इंटरफेस आहे. ओरॅकल दस्तऐवजीकरणानुसार, क्यू इंटरफेसमध्ये 2 सुपरइंटरफेस आहेत, 4 भिन्न इंटरफेस आहेत जे रांगेतून वारशाने मिळतात आणि वर्गांची एक अत्यंत प्रभावी यादी आहे. याचा अर्थ काय? सर्वप्रथम, Java Queue हा कलेक्शन फ्रेमवर्कचा एक भाग आहे आणि कलेक्शन इंटरफेस लागू करतो. त्यामुळे ते कलेक्शन इंटरफेसच्या सर्व पद्धतींना समर्थन देते जसे की समाविष्ट करणे, हटवणे आणि असेच. रांग पुनरावृत्ती करण्यायोग्य इंटरफेस लागू करते, जे ऑब्जेक्टला "प्रत्येक लूपसाठी" विधानाचे लक्ष्य बनविण्यास अनुमती देते.

रांग पद्धती जावा

रांग अनेक पद्धती घोषित करते. इंटरफेसच्या पद्धती म्हणून ते रांगेची अंमलबजावणी करणार्‍या सर्व वर्गांमध्ये प्रतिनिधित्व केले जावे. सर्वात महत्वाच्या रांग पद्धती, Java:

• बुलियन ऑफर() – शक्य असल्यास रांगेत नवीन घटक समाविष्ट करते
• बुलियन अॅड(E e) – शक्य असल्यास रांगेत नवीन घटक समाविष्ट करते. यशाच्या बाबतीत खरे परत येते आणि जागा नसल्यास बेकायदेशीर राज्य अपवाद टाकतो.
• ऑब्जेक्ट पोल() – च्या डोक्यातून एक घटक पुनर्प्राप्त करतो आणि काढून टाकतो. रांग रिकामी असल्यास शून्य परत करते.
• ऑब्जेक्ट रिमूव्ह () - रांगेच्या डोक्यातून एक घटक पुनर्प्राप्त करते आणि काढून टाकते.
• ऑब्जेक्ट पीक() – पुनर्प्राप्त करते, परंतु रांगेच्या डोक्यावरून घटक काढून टाकत नाही. रांग रिकामी असल्यास शून्य परत करते.
• ऑब्जेक्ट एलिमेंट() – पुनर्प्राप्त करते, परंतु रांगेच्या डोक्यावरून घटक काढून टाकत नाही.

Java रांगेचे उप-इंटरफेस

रांग इंटरफेस 4 सबइंटरफेसेस द्वारे वारशाने मिळतो - BlockingDeque<E>, BlockingQueue<E>, Deque<E>, TransferQueue<E> . तुम्ही त्यांना 3 गटांमध्ये विभागू शकता: Deques, Blocking Quues आणि BlockingDeque सह ट्रान्सफर क्यूज प्रथम दोन गटात आहेत. या गटांची एक झलक पाहूया.

Deques

Deque म्हणजे D ouble- E nded Q ueue आणि डेटाच्या दोन्ही शेपटीतून क्यू म्हणून (फर्स्ट-इन-फर्स्ट-आउट/FIFO) किंवा डोक्यावरून स्टॅक (लास्ट-इन-) नावाची दुसरी लोकप्रिय डेटा संरचना म्हणून जोडणे किंवा काढून टाकण्यास समर्थन देते. फर्स्ट-आउट/LIFO). Deque इंटरफेस लागू करणारे वर्ग: ArrayDeque, ConcurrentLinkedDeque, LinkedBlockingDeque, LinkedList.

रांगा अवरोधित करणे

अवरोधित करणारी रांग ही एक रांग आहे जी दोन प्रकरणांमध्ये धागा अवरोधित करते:

• थ्रेड रिकाम्या रांगेतून घटक मिळविण्याचा प्रयत्न करत आहे
• थ्रेड पूर्ण रांगेत घटक ठेवण्याचा प्रयत्न करत आहे

जेव्हा एखादा थ्रेड रिकाम्या रांगेतून आयटम मिळवण्याचा प्रयत्न करतो, तेव्हा तो काही इतर थ्रेडने आयटम रांगेत ठेवेपर्यंत प्रतीक्षा करतो. त्याचप्रमाणे, जेव्हा एखादा थ्रेड घटकांना पूर्ण रांगेत ठेवण्याचा प्रयत्न करतो, तेव्हा तो घटकांसाठी मोकळी जागा मिळविण्यासाठी इतर काही थ्रेड घटकांना रांगेतून बाहेर काढेपर्यंत प्रतीक्षा करतो. नक्कीच, "पूर्ण रांग" ची संकल्पना सूचित करते की रांगेचा आकार मर्यादित आहे, जो सहसा कन्स्ट्रक्टरमध्ये निर्दिष्ट केला जातो. मानक ब्लॉकिंग रांगांमध्ये LinkedBlockingQueue, SynchronousQueue आणि ArrayBlockingQueue यांचा समावेश होतो. BlockingQueue इंटरफेसचे वर्ग लागू करणे : ArrayBlockingQueue, DelayQueue, LinkedBlockingDeque, LinkedBlockingQueue, LinkedTransferQueue, PriorityBlockingQueue, SynchronousQueue. ब्लॉकिंगडेकBlockingQueue साठी उप-इंटरफेस आहे. BlockingDeque जसे की BlockingQueue ही ब्लॉकिंग रांग आहे, परंतु द्विदिशात्मक आहे. त्यामुळे ते Deque इंटरफेसचे गुणधर्म वारसा घेतात. हे बहु-थ्रेडेड अंमलबजावणीसाठी केंद्रित आहे, शून्य घटकांना परवानगी देत ​​​​नाही आणि क्षमता मर्यादित असू शकते. BlockingDeque इंटरफेसची अंमलबजावणी रांग रिकामी असल्यास घटक मिळवणे आणि ती भरलेली असल्यास रांगेत एक घटक जोडणे अवरोधित करते.

हस्तांतरण रांगा

TransferQueue इंटरफेस BlockingQueue इंटरफेसचा विस्तार करतो. तथापि, BlockingQueue इंटरफेस रांगांच्या अंमलबजावणीच्या विपरीत, जेथे रांग रिकामी असल्यास (वाचन) किंवा रांग भरलेली असल्यास (लेखन) थ्रेड अवरोधित केले जाऊ शकतात, दुसर्या प्रवाहाने घटक पुनर्प्राप्त होईपर्यंत TransferQueue इंटरफेस रांग लेखन प्रवाह अवरोधित करतात. यासाठी हस्तांतरण पद्धत वापरा. दुस-या शब्दात, BlockingQueue ची अंमलबजावणी हमी देते की निर्मात्याने तयार केलेला घटक रांगेत असणे आवश्यक आहे, तर TransferQueue ची अंमलबजावणी हमी देते की उत्पादक घटक ग्राहकाला "मिळला" आहे. TransferQueue इंटरफेसची फक्त एक अधिकृत Java अंमलबजावणी आहे — LinkedTransferQueue.

जावा रांग अंमलबजावणी

रांग इंटरफेस लागू करणारे अनेक वर्ग आहेत:

• Queue Java 8 डॉक्स नुसार AbstractQueue , हा अ‍ॅबस्ट्रॅक्ट वर्ग काही रांग ऑपरेशन्सची मूलभूत अंमलबजावणी प्रदान करतो. हे शून्य घटकांना अनुमती देत ​​नाही. अनुक्रमे रांगेत शास्त्रीय ऑफर , पोल आणि पीकवर आधारित आणखी 3 पद्धती जोडणे, काढून टाकणे आणि घटक आहेत . तथापि, ते खोट्या किंवा शून्य रिटर्नद्वारे अपयश दर्शविण्याऐवजी अपवाद टाकतात.
• ArrayBlockingQueue — निश्चित आकाराची FIFO ब्लॉकिंग रांग अॅरेद्वारे समर्थित
• ArrayDeque — डेक इंटरफेसचे आकार बदलण्यायोग्य अॅरे अंमलबजावणी
• ConcurrentLinkedDeque — लिंक केलेल्या नोड्सवर आधारित अनबाउंडेड समवर्ती डेक.
• ConcurrentLinkedQueue — लिंक केलेल्या नोड्सवर आधारित अनबाउंड थ्रेड-सेफ रांग.
• DelayQueue — एक वेळ-आधारित शेड्युलिंग रांग ज्याला ढिगाचा आधार आहे
• LinkedBlockingDeque — डेक इंटरफेसची समवर्ती अंमलबजावणी.
• LinkedBlockingQueue — लिंक्ड नोड्सद्वारे समर्थित FIFO ब्लॉकिंग रांग वैकल्पिकरित्या बाउंडेड
• लिंक्डलिस्ट — यादी आणि डेक इंटरफेसची दुप्पट-लिंक केलेली सूची अंमलबजावणी. सर्व पर्यायी सूची ऑपरेशन्स लागू करते आणि सर्व घटकांना परवानगी देते (शून्यसह)
• LinkedTransferQueue — लिंक्ड नोड्सवर आधारित अनबाउंड ट्रान्सफर रांग
• PriorityBlockingQueue — एक ढीग द्वारे समर्थित एक अमर्याद अवरोधित प्राधान्य रांग
• PriorityQueue — हीप डेटा स्ट्रक्चरवर आधारित अग्रक्रम रांग
• SynchronousQueue — ब्लॉक करणारी रांग जिथे प्रत्येक इन्सर्ट ऑपरेशनला दुसर्‍या थ्रेडद्वारे संबंधित काढून टाकण्याच्या ऑपरेशनची प्रतीक्षा करणे आवश्यक आहे आणि त्याउलट.

LinkedList, ArrayBlockingQueue आणि PriorityQueue ही सर्वात लोकप्रिय अंमलबजावणी आहेत. चला ते पाहू आणि चांगल्या प्रकारे समजून घेण्यासाठी काही उदाहरणे करू.

लिंक्डलिस्ट

Java मध्ये क्लास LinkedList List आणि Deque इंटरफेस लागू करते. तर, हे यादी आणि डेकचे संयोजन आहे, एक द्वि-मार्ग रांग, जी दोन्ही बाजूंनी घटक जोडणे आणि काढून टाकण्यास समर्थन देते. Java LinkedList मध्ये दुहेरी-लिंक केलेली यादी आहे: यादीतील प्रत्येक घटक नोडला कॉल करतो आणि त्यात एक ऑब्जेक्ट आणि दोन शेजारच्या वस्तूंचा संदर्भ असतो - मागील आणि पुढील. मेमरी वापरण्याच्या दृष्टीने लिंक्डलिस्ट फार प्रभावी नाही असे तुम्ही म्हणू शकता. हे खरे आहे, परंतु ही डेटा रचना समाविष्ट आणि हटवण्याच्या ऑपरेशन्सच्या बाबतीत उपयुक्त ठरू शकते. तथापि, आपण त्यांच्यासाठी पुनरावृत्ती वापरल्यासच हे घडते (या प्रकरणात ते सतत घडते). अनुक्रमणिकेद्वारे प्रवेश ऑपरेशन्स इच्छित घटकाच्या शेवटच्या सुरुवातीपासून (जे जवळ असेल) शोधून केले जातात. तथापि, घटकांमधील संदर्भ संचयित करण्यासाठी अतिरिक्त खर्चाबद्दल विसरू नका. तर, LinkedList जावा मधील सर्वात लोकप्रिय रांग अंमलबजावणी आहे. हे List आणि Deque ची अंमलबजावणी देखील आहे आणि ते आम्हाला null सह कोणत्याही वस्तूंचा समावेश असलेली द्विदिशात्मक रांग तयार करण्यास अनुमती देते. LinkedList हा घटकांचा संग्रह आहे.

LinkedList Constructors

पॅरामीटर्सशिवाय LinkedList() रिकामी यादी तयार करण्यासाठी वापरली जाते. LinkedList(Collection<? extensions E> c) निर्दिष्ट संग्रहातील घटक असलेली सूची तयार करण्यासाठी आहे, क्रमाने, ते संग्रहाच्या पुनरावृत्तीद्वारे परत केले जातात.

मुख्य लिंक्डलिस्ट पद्धती:

• add(E घटक) या सूचीच्या शेवटी निर्दिष्ट घटक जोडते;
• add(int index, E element) निर्दिष्‍ट पोझिशन इंडेक्सवर घटक घालतो;
• get(int index) या सूचीतील निर्दिष्ट स्थानावर घटक परत करते;
• remove(int index) पोझिशन इंडेक्सवर असलेला घटक काढून टाकतो;
• काढून टाका(ऑब्जेक्ट o) या सूचीमधून ?o घटकाची पहिली घटना तेथे असल्यास ती काढून टाकते.
• remove() सूचीतील पहिला घटक पुनर्प्राप्त करतो आणि काढून टाकतो.
• addFirst(), addLast() सूचीच्या सुरूवातीस/शेवटमध्ये एक घटक जोडा
• clear() सूचीमधून सर्व घटक काढून टाकते
• समाविष्ट (ऑब्जेक्ट o) सूचीमध्ये o घटक असल्यास सत्य परत येतो.
• indexOf(Object o) o घटकाच्या पहिल्या घटनेची अनुक्रमणिका किंवा -1 सूचीमध्ये नसल्यास.
• सेट(इंट इंडेक्स, ई एलिमेंट) इंडेक्स पोझिशनवरील एलिमेंटला एलिमेंटने बदलतो
• आकार()सूचीमधील घटकांचे प्रमाण मिळवते.
• toArray() पहिल्यापासून शेवटच्या घटकापर्यंत सूचीतील सर्व घटक असलेली अॅरे मिळवते.
• pop() जो स्टॅकमधून एक घटक पॉप करतो (सूचीद्वारे दर्शविला जातो)
• पुश(ई ई) जो घटक स्टॅकवर ढकलतो (या सूचीद्वारे प्रस्तुत)

जावा रांगेचे उदाहरण — लिंक्डलिस्ट (वेगवेगळ्या प्रकारे घटक ठेवणे आणि काढून टाकणे)

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

प्राधान्य रांग

PriorityQueue ही FIFO च्या सर्वसाधारण अर्थामध्ये नेमकी रांग नाही. प्राधान्य रांगेतील घटक त्यांच्या नैसर्गिक क्रमानुसार किंवा रांगेच्या बांधकामाच्या वेळी प्रदान केलेल्या तुलनाकर्त्याद्वारे, कोणता कन्स्ट्रक्टर वापरला जातो यावर अवलंबून असतो. तथापि, हा क्रम नाही जसे की सूची सारख्या रेषीय संरचनेत असू शकतो (सर्वात मोठ्या ते सर्वात लहान किंवा त्याउलट). प्राधान्य मिन हीपवर आधारित अग्रक्रम रांग. हीप ही बायनरी ट्रीवर आधारित डेटा स्ट्रक्चर आहे. प्रत्येक पालकाचे प्राधान्य त्याच्या मुलांच्या प्राधान्यांपेक्षा मोठे असते. जर प्रत्येक पालकाला दोनपेक्षा जास्त मुले नसतील तर झाडाला पूर्ण बायनरी म्हणतात आणि स्तर भरणे वरपासून खालपर्यंत (समान पातळीपासून - डावीकडून उजवीकडे) जाते. बायनरी हीप प्रत्येक वेळी नवीन घटक जोडल्यावर किंवा काढून टाकल्यावर स्वतःची पुनर्रचना होते. मिन-हिपच्या बाबतीत, सर्वात लहान घटक त्याच्या घालण्याच्या क्रमाकडे दुर्लक्ष करून रूटवर जातो. या मिन-हिपवर आधारित प्राधान्यक्रम रांग, म्हणून जर आपल्याकडे पूर्णांकांची PriorityQueue असेल, तर त्याचा पहिला घटक या संख्यांपैकी सर्वात लहान असेल. तुम्ही रूट हटवल्यास, पुढील सर्वात लहान रूट होईल.

मुख्य प्राधान्य रांग पद्धती:

• बुलियन अॅड(ऑब्जेक्ट) निर्दिष्ट घटक प्राधान्य रांगेत समाविष्ट करते. यशाच्या बाबतीत खरे परत येते. रांग भरलेली असल्यास, पद्धत अपवाद दर्शवते.
• बुलियन ऑफर(ऑब्जेक्ट) या प्राधान्य रांगेत निर्दिष्ट घटक समाविष्ट करते. रांग भरली असल्यास, पद्धत चुकीची परत येते.
• बुलियन रिमूव्ह(ऑब्जेक्ट) या रांगेतून निर्दिष्ट घटकाचा एकच प्रसंग काढून टाकतो, जर तो उपस्थित असेल.
• ऑब्जेक्ट पोल() या रांगेचे प्रमुख पुनर्प्राप्त करते आणि काढून टाकते. रांग रिकामी असल्यास शून्य परत करते.
• void clear() प्राधान्य रांगेतील सर्व घटक काढून टाकते.
• ऑब्जेक्ट एलिमेंट() या रांगेचे डोके न काढता पुनर्प्राप्त करते. रांग रिकामी असल्यास NoSuchElementException टाकते.
• ऑब्जेक्ट पीक() रांगेचे डोके न काढता पुनर्प्राप्त करते. रांग रिकामी असल्यास शून्य परत करते.
• रांगेत o घटक असल्यास boolean contains(Object o) खरे मिळवते.
• int size() या रांगेतील घटकांची संख्या परत करते.

PriorityQueue चे उदाहरण

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

ArrayBlockingQueue ची अंतर्गत डेटा रचनाघटक संचयित करण्यासाठी गोलाकार अॅरेवर आधारित आहे. रांगेच्या शेपटीत नवीन घटक घातल्यास ही एक सामान्य रांग (FIFO) असते आणि एक्स्ट्रॅक्शन ऑपरेशन्स रांगेच्या डोक्यावरून एक घटक परत करतात. एकदा तयार केल्यावर रांगेची क्षमता बदलता येत नाही. संपूर्ण रांगेत घटक घालण्याचा (ठेवण्याचा) प्रयत्न प्रवाह अवरोधित करण्यास कारणीभूत ठरतो; रिकाम्या रांगेतून घटक घेण्याचा प्रयत्न केल्याने थ्रेड ब्लॉक होतो. आम्ही आधी म्हटल्याप्रमाणे, ही अॅरे गोलाकार आहे. याचा अर्थ असा की अॅरेचे पहिले आणि शेवटचे घटक तार्किकदृष्ट्या समीप मानले जातात. प्रत्येक वेळी जेव्हा तुम्ही एलिमेंटो रांगेत टाकता किंवा रांगेतून काढून टाकता तेव्हा रांग हेड आणि शेपटीच्या घटकांचे निर्देशांक वाढवते. जर काही इंडेक्स अॅरेच्या शेवटच्या घटकाला पुढे नेत असेल, तर ते 0 पासून रीस्टार्ट होते. म्हणून, डोके काढून टाकण्याच्या बाबतीत (नेहमीच्या अॅरेप्रमाणे) रांगेला सर्व घटक बदलण्याची गरज नाही. तथापि, मध्यभागी घटक काढून टाकण्याच्या बाबतीत (Iterator.remove वापरून), घटक स्थलांतरित केले जातात. ArrayBlockingQueue उत्पादक (घटक घालणे) आणि ग्राहक (घटक काढणे) यांच्या प्रतीक्षा प्रवाहाचे काम ऑर्डर करण्यासाठी कन्स्ट्रक्टरमध्ये योग्य पॅरामीटरसह अतिरिक्त निष्पक्षता धोरणास समर्थन देते . डीफॉल्टनुसार, ऑर्डरची हमी दिली जात नाही. तथापि रांग "fair == true" सह तयार केली असल्यास, ArrayBlockingQueue वर्गाची अंमलबजावणी FIFO क्रमाने थ्रेड प्रवेश प्रदान करते. इक्विटी सामान्यत: बँडविड्थ कमी करते, परंतु अस्थिरता देखील कमी करते आणि संसाधने संपण्यास प्रतिबंध करते.

ArrayBlockingQueue वर्ग कंस्ट्रक्टर

• ArrayBlockingQueue (int क्षमता) निश्चित क्षमतेची आणि डीफॉल्ट प्रवेश धोरणासह रांग तयार करते.
• ArrayBlockingQueue (int क्षमता, बुलियन फेअर) एक निश्चित क्षमता आणि निर्दिष्ट प्रवेश धोरणासह एक रांग तयार करते.
• ArrayBlockingQueue (int Capacity, boolean fair, Collection <? extends E> c) प्रवेश धोरणाद्वारे निर्दिष्ट केलेल्या निश्चित क्षमतेसह एक रांग तयार करते आणि रांगेतील घटक समाविष्ट करते.

येथे आपल्याला BlockingQueueExample उदाहरण मिळाले आहे. आम्ही एका घटकाची क्षमता आणि योग्य ध्वज असलेली ArrayBlockingQueue ची रांग तयार करतो. दोन धागे सुरु आहेत. त्यापैकी पहिला, प्रोड्यूसर थ्रेड, पुट पद्धतीचा वापर करून मेसेज अॅरेमधून संदेशांची रांग लावतो. दुसरा, Consumer, थ्रेड टेक मेथड वापरून रांगेतील घटक वाचतो आणि कन्सोलमध्ये दाखवतो. घटकांचा क्रम रांगेसाठी नैसर्गिक आहे.

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 कोर्समधील व्हिडिओ धडा पाहण्याची सूचना देतो

निष्कर्ष

• रांगेचा वापर रांगेच्या शेवटी घटक घालण्यासाठी केला जातो आणि रांगेच्या सुरुवातीपासून काढून टाकला जातो. हे FIFO संकल्पनेचे अनुसरण करते.
• Java Queue हा कलेक्शन फ्रेमवर्कचा एक भाग आहे आणि कलेक्शन इंटरफेस लागू करतो. त्यामुळे ते कलेक्शन इंटरफेसच्या सर्व पद्धतींना समर्थन देते जसे की समाविष्ट करणे, हटवणे आणि असेच.
• रांगेची सर्वात वारंवार वापरली जाणारी अंमलबजावणी म्हणजे LinkedList, ArrayBlockingQueue आणि PriorityQueue.
• प्राधान्य रांगेतील घटक त्यांच्या नैसर्गिक क्रमानुसार किंवा रांगेच्या बांधकामाच्या वेळी प्रदान केलेल्या तुलनाकर्त्याद्वारे, कोणता कन्स्ट्रक्टर वापरला जातो यावर अवलंबून असतो.
• BlockingQueues वर कोणतेही शून्य ऑपरेशन केले असल्यास, NullPointerException टाकले जाते.