एलएमएक्स विघटन डिजाइन पैटर्न क्या है?

Question

क्या कोई मुझे बता सकता है कि सरल उदाहरण के साथ विघटनकर्ता डिजाइन पैटर्न क्या है? मैं इस डिजाइन पैटर्न की मूल बातें जानना चाहूंगा।

Answer 1

एक साधारण गूगल मुझे मार्टिन Fowler

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

GitHub project में जावा कोड + डॉक्टर शामिल है।

Answer 2

मैंने इसके चारों ओर पढ़ने के लिए कुछ दिन बिताए और मैं आर्किटेक्चररी के साथ पकड़ने के साथ-साथ इस डिजाइन पैटर्न के आसपास आने के कारणों से पकड़ने के लिए शुरू कर रहा हूं।

कैसे एक श्वेत पत्र, स्रोत कोड और यूएमएल चित्र आप http://martinfowler.com/articles/lmax.html

Answer 3

पर शुरू this article से कोशिश कर सकते के लिए लिंक सहित एक अच्छा वर्णन के लिए https://github.com/trevorbernard/disruptor-examples

कोशिश को लागू करने का एक सरल कोड उदाहरण के लिए:

विघटनकर्ता पैटर्न एक बैचिंग कतार है जो एक परिपत्र सरणी (यानी अंगूठी बफर) द्वारा पूर्व-आवंटित स्थानांतरणसे भरा हुआ हैऑब्जेक्ट्स जो स्मृति-बाधाओं का उपयोग करता है ताकि उत्पादकों को सिंक्रनाइज़ किया जा सके और अनुक्रमों के माध्यम से उपभोक्ताओं को सिंक्रनाइज़ किया जा सके।

सौभाग्य से आपको इसका उपयोग करने के लिए विघटनकारी पैटर्न के आंतरिक विवरण को समझने की आवश्यकता नहीं है। यदि आपको कोड के माध्यम से समझना आसान लगता है, तो नीचे हैलो वर्ल्डCoralQueue, अंतर-थ्रेड संचार के लिए अल्ट्रा-लो-विलंबता कतार जो विघटनकारी पैटर्न लागू करती है।

package com.coralblocks.coralqueue.sample.queue; 

import com.coralblocks.coralqueue.AtomicQueue; 
import com.coralblocks.coralqueue.Queue; 
import com.coralblocks.coralqueue.util.Builder; 

public class Basics { 

    public static void main(String[] args) { 

     final Queue<StringBuilder> queue = new AtomicQueue<StringBuilder>(1024, new Builder<StringBuilder>() { 
      @Override 
      public StringBuilder newInstance() { 
       return new StringBuilder(1024); 
      } 
     }); 

     Thread producer = new Thread(new Runnable() { 

      private final StringBuilder getStringBuilder() { 
       StringBuilder sb; 
       while((sb = queue.nextToDispatch()) == null) { 
        // queue can be full if the size of the queue 
        // is small and/or the consumer is too slow 

        // busy spin (you can also use a wait strategy instead) 
       } 
       return sb; 
      } 

      @Override 
      public void run() { 

       StringBuilder sb; 

       while(true) { // the main loop of the thread 

        // (...) do whatever you have to do here... 

        // and whenever you want to send a message to 
        // the other thread you can just do: 
        sb = getStringBuilder(); 
        sb.setLength(0); 
        sb.append("Hello!"); 
        queue.flush(); 

        // you can also send in batches to increase throughput: 
        sb = getStringBuilder(); 
        sb.setLength(0); 
        sb.append("Hi!"); 

        sb = getStringBuilder(); 
        sb.setLength(0); 
        sb.append("Hi again!"); 

        queue.flush(); // dispatch the two messages above... 
       } 
      } 
     }, "Producer"); 

     Thread consumer = new Thread(new Runnable() { 

      @Override 
      public void run() { 

       while (true) { // the main loop of the thread 

        // (...) do whatever you have to do here... 

        // and whenever you want to check if the producer 
        // has sent a message you just do: 

        long avail; 
        while((avail = queue.availableToPoll()) == 0) { 
         // queue can be empty! 
         // busy spin (you can also use a wait strategy instead) 
        } 

        for(int i = 0; i < avail; i++) { 
         StringBuilder sb = queue.poll(); 
         // (...) do whatever you want to do with the data 
         // just don't call toString() to create garbage... 
         // copy byte-by-byte instead... 
        } 
        queue.donePolling(); 
       } 
      } 
     }, "Consumer"); 

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