ஒரே நேரத்தில் வரிசைகள்

தடுக்காத வரிசைகள்

இணைக்கப்பட்ட முனைகளில் த்ரெட்-பாதுகாப்பான மற்றும் மிக முக்கியமாகத் தடுக்காத வரிசை செயலாக்கங்கள்.

ConcurrentLinkedQueue<E> - இது குப்பை சேகரிப்பாளருடன் வேலை செய்வதற்கு ஏற்ற காத்திருப்பு-இலவச அல்காரிதத்தைப் பயன்படுத்துகிறது. இந்த அல்காரிதம் CAS இல் கட்டமைக்கப்பட்டுள்ளதால், மிகவும் திறமையானது மற்றும் மிக வேகமாக உள்ளது. அளவு () முறைநீண்ட நேரம் இயங்கக்கூடியது, எனவே அதை எல்லா நேரத்திலும் இழுக்காமல் இருப்பது நல்லது.

ConcurrentLinkedDeque<E> - Deque என்பது இரட்டை முடிவு வரிசையைக் குறிக்கிறது. இதன் பொருள் தரவுகளை இரு பக்கங்களிலிருந்தும் சேர்க்கலாம் மற்றும் இழுக்கலாம். அதன்படி, வகுப்பு இரண்டு செயல்பாட்டு முறைகளையும் ஆதரிக்கிறது: FIFO (First In First Out) மற்றும் LIFO (Last In First Out).

நடைமுறையில், LIFO முற்றிலும் அவசியமானால் ConcurrentLinkedDeque ஐப் பயன்படுத்த வேண்டும், ஏனெனில் முனைகளின் இருதரப்புத்தன்மை காரணமாக, இந்த வகுப்பு ConcurrentLinkedQueue உடன் ஒப்பிடும்போது செயல்திறனில் பாதியை இழக்கிறது .

import java.util.concurrent.ConcurrentLinkedQueue;

public class  ConcurrentLinkedQueueExample {
   public static void main(String[] args) {
       ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();

       Thread producer = new Thread(new Producer(queue));
       Thread consumer = new Thread(new Consumer(queue));

       producer.start();
       consumer.start();
   }
}

class Producer implements Runnable {

   ConcurrentLinkedQueue<String> queue;
   Producer(ConcurrentLinkedQueue<String> queue){
       this.queue = queue;
   }
   public void run() {
       System.out.println("Class for adding items to the queue");
       try {
           for (int i = 1; i < 5; i++) {
               queue.add("Item #" + i);
               System.out.println("Added: Item #" + i);
               Thread.sleep(300);
           }
       } catch (InterruptedException ex) {
           ex.printStackTrace();
           Thread.currentThread().interrupt();
       }
   }
}

class Consumer implements Runnable {

   ConcurrentLinkedQueue<String> queue;
   Consumer(ConcurrentLinkedQueue<String> queue){
       this.queue = queue;
   }

   public void run() {
       String str;
       System.out.println("Class for getting items from the queue");
       for (int x = 0; x < 5; x++) {
           while ((str = queue.poll()) != null) {
               System.out.println("Pulled out: " + str);
           }
           try {
               Thread.sleep(600);
           } catch (InterruptedException ex) {
               ex.printStackTrace();
               Thread.currentThread().interrupt();
           }
       }
   }
}

வரிசைகளைத் தடுப்பது

BlockingQueue<E> இடைமுகம் - நிறைய தரவு இருந்தால், ConcurrentLinkedQueue போதாது.

த்ரெட்கள் தங்கள் வேலையைச் செய்யத் தவறினால், நீங்கள் எளிதாக OutOfMemmoryException ஐப் பெறலாம் . இதுபோன்ற வழக்குகள் எழாமல் இருக்க, வரிசை மற்றும் நிபந்தனை பூட்டுகளை நிரப்புவதற்கும் வேலை செய்வதற்கும் வெவ்வேறு முறைகள் இருப்பதால் வேலை செய்வதற்கான BlockingQueue உள்ளது.

BlockingQueue பூஜ்ய கூறுகளை அடையாளம் காணவில்லை மற்றும்அத்தகைய உறுப்பைச் சேர்க்க அல்லது பெற முயற்சிக்கும்போது NullPointerException ஐ வீசுகிறது. காலக்கெடுவிற்குள் எந்த உறுப்பும் வரிசையில் வைக்கப்படவில்லை என்றால், வாக்கெடுப்பு முறை பூஜ்ய உறுப்பை வழங்கும்.

BlockingQueue<E> அமலாக்கங்கள்

எங்கள் BlockingQueue செயலாக்கங்கள் ஒவ்வொன்றையும் கூர்ந்து கவனிப்போம் :

ArrayBlockingQueue<E> என்பது கிளாசிக் ரிங் பஃப்பரில் கட்டமைக்கப்பட்ட தடுப்பு வரிசை வகுப்பாகும். இங்கே நாம் பூட்டுகளின் "நேர்மை" நிர்வகிக்க வாய்ப்பு உள்ளது. நியாயமான=தவறான (இயல்புநிலை) எனில், நூல் வரிசைப்படுத்துதல் உத்தரவாதம் இல்லை.

DelayQueue<E நீட்டிக்கிறது தாமதம்> என்பது ஒரு குறிப்பிட்ட தாமதத்திற்குப் பிறகு மட்டுமே வரிசையில் இருந்து உறுப்புகளை இழுக்க உங்களை அனுமதிக்கும் ஒரு வகுப்பாகும், இது தாமதமான இடைமுகத்தின் getDelay முறையின் மூலம் ஒவ்வொரு உறுப்புகளிலும் வரையறுக்கப்படுகிறது .

LinkedBlockingQueue<E> என்பது "இரண்டு பூட்டு வரிசை" வழிமுறையில் செயல்படுத்தப்படும் இணைக்கப்பட்ட முனைகளில் ஒரு தடுப்பு வரிசையாகும்: முதல் பூட்டு சேர்ப்பதற்காக, இரண்டாவது வரிசையில் இருந்து ஒரு உறுப்பை இழுக்க வேண்டும். பூட்டுகள் காரணமாக, ArrayBlockingQueue உடன் ஒப்பிடும்போது , ​​இந்த வகுப்பு அதிக செயல்திறன் கொண்டது, ஆனால் அதற்கு அதிக நினைவகம் தேவைப்படுகிறது. வரிசை அளவு கன்ஸ்ட்ரக்டர் மூலம் அமைக்கப்பட்டது மற்றும் முன்னிருப்பாக Integer.MAX_VALUEக்கு சமமாக இருக்கும்.

PriorityBlockingQueue<E> என்பது PriorityQueue ஐ விட பல-திரிக்கப்பட்ட ரேப்பர் ஆகும். உறுப்பு சேர்க்கப்படும் தர்க்கத்திற்கு ஒப்பீட்டாளர் பொறுப்பு. சிறிய உறுப்பு முதலில் வெளியே வருகிறது.

SynchronousQueue<E> - FIFO (முதல்-இன்-முதல்-அவுட்) கொள்கையின்படி வரிசை செயல்படுகிறது. "நுகர்வோர்" இழை வரிசையில் இருந்து உறுப்பை இழுக்கும் வரை ஒவ்வொரு செருகும் செயல்பாடும் "தயாரிப்பாளர்" நூலைத் தடுக்கும் மற்றும் நேர்மாறாக, "தயாரிப்பாளர்" உறுப்பைச் செருகும் வரை "நுகர்வோர்" காத்திருக்கும்.

BlockingDeque<E> என்பது இருதரப்பு தடுப்பு வரிசைக்கான கூடுதல் முறைகளை விவரிக்கும் ஒரு இடைமுகமாகும். வரிசையின் இருபுறமும் தரவைச் செருகலாம் மற்றும் வெளியே இழுக்கலாம்.

LinkedBlockingDeque<E> என்பது இணைக்கப்பட்ட முனைகளில் ஒரு இருதரப்பு தடுப்பு வரிசையாகும், இது ஒரு பூட்டுடன் எளிய இருதிசை பட்டியலாக செயல்படுத்தப்படுகிறது. வரிசை அளவு கன்ஸ்ட்ரக்டர் மூலம் அமைக்கப்பட்டது மற்றும் முன்னிருப்பாக Integer.MAX_VALUEக்கு சமமாக இருக்கும்.

TransferQueue<E> - இடைமுகம் சுவாரஸ்யமானது, வரிசையில் ஒரு உறுப்பு சேர்க்கப்படும் போது, ​​மற்றொரு நுகர்வோர் நூல் வரிசையிலிருந்து உறுப்பை இழுக்கும் வரை செருகும் தயாரிப்பாளர் நூலைத் தடுக்க முடியும்குறிப்பிட்ட காலக்கெடுவுக்கான காசோலையை நீங்கள் சேர்க்கலாம் அல்லது நிலுவையில் உள்ள நுகர்வோர்களுக்கான காசோலையை அமைக்கலாம் . இதன் விளைவாக, ஒத்திசைவற்ற மற்றும் ஒத்திசைவான செய்திகளுக்கான ஆதரவுடன் தரவு பரிமாற்ற பொறிமுறையைப் பெறுகிறோம்.

LinkedTransferQueue<E> என்பது ஸ்லாக் அல்காரிதம் கொண்ட இரட்டை வரிசைகளின் அடிப்படையில் TransferQueue இன் செயல்படுத்தல் ஆகும்செயலற்ற நிலையில் CAS (மேலே காண்க) மற்றும் நூல் பார்க்கிங் ஆகியவற்றை அதிகமாகப் பயன்படுத்துகிறது.