Disruptor Java: पूर्ण गाइड उदाहरणों के साथ

1. यह क्या है और क्यों ज़रूरी है

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

Disruptor जिस मुख्य समस्या को हल करता है वह है थ्रेड्स के बीच रिसोर्सेज के लिए 'कंपटीशन'। पारंपरिक क्यू में कई प्रोड्यूसर और कंज्यूमर लॉक्स के लिए प्रतिस्पर्धा करते हैं, जिससे परफॉरमेंस गिरती है। Disruptor 'सीक्वेंस बैरियर्स' और ऑप्टिमिस्टिक लॉकिंग (CAS - Compare-And-Swap) का उपयोग करता है, जिससे माइक्रोसेकंड्स में लेटेंसी और प्रति सेकंड लाखों मैसेज का थ्रूपुट संभव होता है।

यह लाइब्रेरी उन सिस्टम्स के लिए आदर्श है जहाँ इवेंट प्रोसेसिंग की स्पीड महत्वपूर्ण है: स्टॉक एक्सचेंज प्लेटफॉर्म, गेम सर्वर, लॉग प्रोसेसिंग सिस्टम, हाई-लोड वेब एप्लिकेशन। Disruptor कई आधुनिक फ्रेमवर्क्स जैसे Apache Storm और कुछ Event Sourcing इम्प्लीमेंटेशन का आधार है।

2. इंस्टॉलेशन

Disruptor Maven Central के माध्यम से उपलब्ध है। प्रोजेक्ट में उपयोग के लिए अपने pom.xml (Maven) में यह डिपेंडेंसी जोड़ें:

<dependency>
    <groupId>com.lmax</groupId>
    <artifactId>disruptor</artifactId>
    <version>4.0.0</version>
</dependency>

Gradle (build.gradle) के लिए:

implementation 'com.lmax:disruptor:4.0.0'

अगर आप कोई और डिपेंडेंसी मैनेजर उपयोग करते हैं, तो Maven Central से JAR डाउनलोड करें।

3. क्विक स्टार्ट — न्यूनतम कार्यशील उदाहरण

इस उदाहरण में हम एक सरल Disruptor बनाएंगे जो स्ट्रिंग इवेंट्स लेता है और उन्हें कंसोल पर प्रिंट करता है।

import com.lmax.disruptor.*;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.util.DaemonThreadFactory;

// 1. इवेंट क्लास डिफाइन करें
public class StringEvent {
    private String value;

    public String getValue() { return value; }
    public void setValue(String value) { this.value = value; }
}

// 2. इवेंट फैक्ट्री (रीयूज़ के लिए खाली इवेंट बनाती है)
public class StringEventFactory implements EventFactory<StringEvent> {
    @Override
    public StringEvent newInstance() {
        return new StringEvent();
    }
}

// 3. इवेंट हैंडलर (Consumer)
public class StringEventHandler implements EventHandler<StringEvent> {
    @Override
    public void onEvent(StringEvent event, long sequence, boolean endOfBatch) {
        System.out.println("प्राप्त हुआ: " + event.getValue());
    }
}

// 4. मुख्य क्लास
public class QuickStart {
    public static void main(String[] args) throws InterruptedException {
        // रिंग बफर का साइज़ (2 की पावर होना चाहिए)
        int bufferSize = 1024;

        // Disruptor बनाएं
        Disruptor<StringEvent> disruptor = new Disruptor<>(
            new StringEventFactory(),
            bufferSize,
            DaemonThreadFactory.INSTANCE
        );

        // हैंडलर कनेक्ट करें
        disruptor.handleEventsWith(new StringEventHandler());

        // Disruptor स्टार्ट करें
        disruptor.start();

        // RingBuffer का रेफरेंस लें
        RingBuffer<StringEvent> ringBuffer = disruptor.getRingBuffer();

        // इवेंट पब्लिश करें
        for (int i = 0; i < 10; i++) {
            long sequence = ringBuffer.next(); // स्लॉट कैप्चर करें
            try {
                StringEvent event = ringBuffer.