जावा में कार्य कतारें: ThreadPoolExecutor से Disruptor तक

जावा में कार्य कतारें: अंतर्निहित तंत्र से आधुनिक फ्रेमवर्क तक

कार्य कतारें (Task Queues) स्केलेबल और दोष-सहिष्णु Java अनुप्रयोगों के निर्माण के लिए एक मूलभूत पैटर्न हैं। वे व्यावसायिक तर्क को थ्रेड प्रबंधन से अलग करने, लोड को संतुलित करने और कार्यों को अतुल्यकालिक रूप से संसाधित करने की अनुमति देते हैं। इस लेख में, हम जावा में कार्य कतारों के मुख्य कार्यान्वयन, उनकी आर्किटेक्चर, कोड उदाहरण और उपयोग के परिदृश्यों का विश्लेषण करेंगे।

1. अंतर्निहित तंत्र: ThreadPoolExecutor और BlockingQueue

मानक Java लाइब्रेरी (java.util.concurrent) कार्य कतारों के साथ काम करने के लिए शक्तिशाली उपकरणों का एक सेट प्रदान करती है। मूल वर्ग ThreadPoolExecutor है, जो थ्रेड पूल का प्रबंधन करता है और प्रतीक्षा कार्यों को संग्रहीत करने के लिए कतार का उपयोग करता है।

मूल उदाहरण:

import java.util.concurrent.*;\n\npublic class TaskQueueExample {\n    public static void main(String[] args) {\n        // थ्रेड पूल बनाएँ: corePoolSize=2, maxPoolSize=4, 100 कार्यों के लिए कतार\n        ThreadPoolExecutor executor = new ThreadPoolExecutor(\n            2, // corePoolSize\n            4, // maximumPoolSize\n            60, // keepAliveTime\n            TimeUnit.SECONDS,\n            new LinkedBlockingQueue<>(100) // कार्य कतार\n        );\n\n        // कार्य सबमिट करें\n        for (int i = 0; i < 10; i++) {\n            final int taskId = i;\n            executor.submit(() -> {\n                System.out.println("कार्य " + taskId + " थ्रेड द्वारा निष्पादित किया जा रहा है " + \n                                   Thread.currentThread().getName());\n                try {\n                    Thread.sleep(1000);\n                } catch (InterruptedException e) {\n                    Thread.currentThread().interrupt();\n                }\n            });\n        }\n\n        // सही ढंग से समाप्त करें\n        executor.shutdown();\n    }\n}

ThreadPoolExecutor के लिए कतारों के प्रकार:

\n
• LinkedBlockingQueue — लिंक्ड सूची पर आधारित असीमित कतार। उन सिस्टमों के लिए उपयुक्त जहाँ कार्यों की संख्या पहले से ज्ञात नहीं है।
\n
• ArrayBlockingQueue — ऐरे पर आधारित सीमित कतार। प्रतीक्षा कार्यों की अधिकतम संख्या को नियंत्रित करने की अनुमति देता है।
\n
• SynchronousQueue — बिना क्षमता वाली कतार: प्रत्येक put() take() की प्रतीक्षा करता है। थ्रेड्स को सीधे कार्य पास करने के लिए उपयोग किया जाता है।
\n
• PriorityBlockingQueue — प्राथमिकता वाली कतार। कार्य निर्दिष्ट तुलनित्र के अनुसार क्रमबद्ध होते हैं।
\n

2. कतारों पर आधारित Producer-Consumer आर्किटेक्चर

क्लासिक Producer-Consumer पैटर्न BlockingQueue का उपयोग करके आसानी से कार्यान्वित किया जाता है। उत्पादक (producers) कतार में कार्य रखते हैं, और उपभोक्ता (consumers) प्रसंस्करण के लिए उन्हें निकालते हैं।

कार्यान्वयन उदाहरण:

import java.util.concurrent.*;\n\npublic class ProducerConsumerExample {\n    private static final BlockingQueue<String> queue = new LinkedBlockingQueue<>(5);\n\n    static class Producer implements Runnable {\n        @Override\n        public void run() {\n            try {\n                for (int i = 0; i < 10; i++) {\n                    String task = "कार्य-" + i;\n                    queue.put(task); // यदि कतार भरी है तो ब्लॉक हो जाता है\n                    System.out.println("उत्पादित: " + task);\n                    Thread.sleep(100);\n                }\n            } catch (InterruptedException e) {\n                Thread.currentThread().interrupt();\n            }\n        }\n    }\n\n    static class Consumer implements Runnable {\n        @Override\n        public void run() {\n            try {\n                while (true) {\n                    String task = queue.take(); // यदि कतार खाली है तो ब्लॉक हो जाता है\n                    System.out.printl