जावा में समवर्तीता और मल्टीथ्रेडिंग: उन्नत तकनीकें

जावा में समवर्तीता और मल्टीथ्रेडिंग: उन्नत स्तर

जावा में मल्टीथ्रेडिंग सबसे शक्तिशाली और साथ ही जटिल विषयों में से एक है। प्रारंभिक स्तर पर हम synchronized और Thread का उपयोग करते हैं, लेकिन प्रदर्शनकारी और स्केलेबल सिस्टम बनाने के लिए गहरी समझ की आवश्यकता होती है। इस लेख में, हम समवर्तीता के उन्नत तंत्रों पर चर्चा करेंगे: थ्रेड पूल, ForkJoinPool, CompletableFuture के साथ एसिंक्रोनस प्रोग्रामिंग, लॉक का सूक्ष्म समायोजन और मेमोरी के साथ कार्य करना। यह सामग्री उन डेवलपर्स के लिए है जो पहले से मल्टीथ्रेडिंग की मूल बातों से परिचित हैं।

1. थ्रेड पूल के साथ उन्नत कार्य: ExecutorService और कॉन्फ़िगरेशन

ExecutorService का उपयोग औद्योगिक विकास का मानक है। हालांकि, मानक Executors.newFixedThreadPool(10) हमेशा उपयुक्त नहीं होता है। आइए ThreadPoolExecutor के सूक्ष्म समायोजन पर विचार करें।

import java.util.concurrent.*;\n\npublic class CustomThreadPool {\n    public static void main(String[] args) {\n        int corePoolSize = 4;\n        int maxPoolSize = 8;\n        long keepAliveTime = 30;\n        TimeUnit unit = TimeUnit.SECONDS;\n        BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(100);\n\n        ThreadPoolExecutor executor = new ThreadPoolExecutor(\n                corePoolSize,\n                maxPoolSize,\n                keepAliveTime,\n                unit,\n                workQueue,\n                new ThreadPoolExecutor.CallerRunsPolicy() // संतृप्ति नीति\n        );\n\n        // पूल की स्थिति की निगरानी\n        executor.submit(() -> {\n            System.out.println("सक्रिय थ्रेड: " + executor.getActiveCount());\n            System.out.println("पूर्ण कार्य: " + executor.getCompletedTaskCount());\n        });\n\n        executor.shutdown();\n    }\n}

मुख्य पैरामीटर:

\n
• corePoolSize — थ्रेड्स की न्यूनतम संख्या जो बिना कार्यों के भी बनी रहती है।
\n
• maxPoolSize — थ्रेड्स की अधिकतम संख्या।
\n
• keepAliveTime — अतिरिक्त थ्रेड्स का जीवनकाल।
\n
• workQueue — कार्यों की कतार। सीमित आकार वाला ArrayBlockingQueue मेमोरी ओवरफ्लो को रोकता है।
\n
• संतृप्ति नीति — क्या करना है जब कतार भरी हो और सभी थ्रेड व्यस्त हों। CallerRunsPolicy कॉल करने वाले थ्रेड को धीमा कर देता है।
\n

लंबी I/O कार्यों के लिए corePoolSize बढ़ाना बेहतर है, CPU-बाउंड कार्यों के लिए Runtime.getRuntime().availableProcessors() पर ध्यान दें।

2. ForkJoinPool और पुनरावर्ती कार्य

ForkJoinPool उन कार्यों के लिए एक विशेष पूल है जिन्हें उप-कार्यों में विभाजित किया जा सकता है (विभाजित करो और शासन करो)। यह कार्य-चोरी (work stealing) का कुशलतापूर्वक उपयोग करता है।

उदाहरण: एक सरणी के तत्वों के योग की पुनरावर्ती गणना।

import java.util.concurrent.RecursiveTask;\nimport java.util.concurrent.ForkJoinPool;\n\npublic class SumTask extends RecursiveTask<Long> {\n    private static final int THRESHOLD = 1000;\n    private final int[] array;\n    private final int start;\n    private final int end;\n\n    public SumTask(int[] array, int start, int end) {\n        this.array = array;\n        this.start = start;\n        this.end = end;\n    }\n\n    @Override\n    protected Long compute() {\n        if (end - start <= THRESHOLD) {\n            long sum = 0;\n            for (int i = start; i < end; i++) {\n                sum += array[i];\n            }\n            return sum;\n        }\n        int mid = (start + end) / 2;\n        SumTask leftTask = new SumTask(array, start, mid);\n        SumTask rightTask = new SumTask(array, mid, end);\n\n        leftTask.fork(); // एसिंक्रोनस लॉन्च\n        long rightResult = rightTask.compute(); // गणना करें