मल्टीथ्रेडेड जावा एप्लिकेशन में डेटा बफरिंग

Question

मेरे पास एक बहु थ्रेडेड एप्लिकेशन है जिसमें एक निर्माता थ्रेड और कई उपभोक्ता धागे हैं। डेटा को साझा थ्रेड सुरक्षित संग्रह में संग्रहीत किया जाता है और बफर में पर्याप्त डेटा होने पर डेटाबेस में फ़्लश किया जाता है।

javadocs से

-

BlockingQueue<E> 

एक कतार है कि इसके साथ ही आपरेशन जब एक तत्व को पुन: प्राप्त कतार गैर खाली बनने के लिए, और अंतरिक्ष के लिए प्रतीक्षा कतार में उपलब्ध होने के लिए जब एक तत्व भंडारण इंतजार है कि समर्थन करता है ।

take() 

इस कतार के सिर को पुनर्प्राप्त और हटा देता है, जब तक कोई तत्व उपलब्ध न हो जाए, तब तक आवश्यक हो।

मेरे सवालों -

1. एक और संग्रह एक ई [] ले (पूर्णांक एन) विधि है कि है? यानी अवरुद्ध कतार एक तत्व उपलब्ध होने तक प्रतीक्षा करता है। मैं क्या चाहता हूं है कि इसे 100 या 200 तत्व उपलब्ध होने तक प्रतीक्षा करनी चाहिए।
2. वैकल्पिक रूप से, क्या कोई और तरीका है जिसका उपयोग मैं मतदान के बिना समस्या का समाधान करने के लिए कर सकता हूं?

Answer 1

मुझे लगता है कि एक ही रास्ता है या तो BlockingQueue के कुछ कार्यान्वयन को बढ़ाने या take का उपयोग करके किसी प्रकार की उपयोगिता विधि बनाएं:

public <E> void take(BlockingQueue<E> queue, List<E> to, int max) 
     throws InterruptedException { 

    for (int i = 0; i < max; i++) 
     to.add(queue.take()); 
} 

Answer 2

मैं नहीं यकीन है कि तुम वहाँ मानक पुस्तकालय है कि take(int n) प्रकार विधि में एक समान वर्ग अगर हूँ, लेकिन आप बहुत ज्यादा परेशानी के बिना है कि समारोह में जोड़ने के लिए डिफ़ॉल्ट BlockingQueue रैप करने के लिए सक्षम होना चाहिए, क्या नहीं सोच?

वैकल्पिक परिदृश्य एक क्रिया को ट्रिगर करना होगा जहां आप संग्रह में तत्व डालते हैं, जहां आपके द्वारा निर्धारित थ्रेसहोल्ड फ्लशिंग को ट्रिगर करेगा।

Answer 3

drainTo विधि बिल्कुल वही नहीं है जो आप खोज रहे हैं, लेकिन क्या यह आपके उद्देश्य की सेवा करेगा?

http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/BlockingQueue.html#drainTo(java.util.Collection, पूर्णांक)

संपादित

आप take और drainTo के संयोजन का उपयोग takemin अवरुद्ध एक से थोड़ा अधिक performant बैच को लागू कर सकते हैं:

public <E> void drainTo(final BlockingQueue<E> queue, final List<E> list, final int min) throws InterruptedException 
{ 
    int drained = 0; 
    do 
    { 
    if (queue.size() > 0) 
     drained += queue.drainTo(list, min - drained); 
    else 
    { 
     list.add(queue.take()); 
     drained++; 
    } 
    } 
    while (drained < min); 
} 

Answer 4

तो यह एक थ्रेडसेफ कतार होना चाहिए जो आपको तत्वों की मनमाना संख्या लेने पर रोक देगा। थ्रेडिंग कोड को सत्यापित करने के लिए और अधिक आंखों का स्वागत किया जाएगा।

package mybq; 

import java.util.ArrayList; 
import java.util.LinkedList; 
import java.util.List; 

public class ChunkyBlockingQueue<T> { 
    protected final LinkedList<T> q = new LinkedList<T>(); 
    protected final Object lock = new Object(); 

    public void add(T t) { 
     synchronized (lock) { 
      q.add(t); 
      lock.notifyAll(); 
     } 
    } 

    public List<T> take(int numElements) { 
     synchronized (lock) { 
      while (q.size() < numElements) { 
       try { 
        lock.wait(); 
       } catch (InterruptedException e) { 
        Thread.currentThread().interrupt(); 
       } 
      } 
      ArrayList<T> l = new ArrayList<T>(numElements); 
      l.addAll(q.subList(0, numElements)); 
      q.subList(0, numElements).clear(); 
      return l; 
     } 
    } 
}