Kotlin में कार्य कतारों के साथ कार्य करना: व्यवहार में

परिचय: Kotlin में कार्य कतारों की आवश्यकता क्यों?

आधुनिक एप्लिकेशनों को अक्सर समानांतर डेटा प्रोसेसिंग, बैकग्राउंड ऑपरेशन और एसिंक्रोनस कॉल की आवश्यकता होती है। कार्यों के उचित प्रबंधन के बिना, आपका कोड प्रदर्शन समस्याओं, मेमोरी लीक या इंटरफ़ेस के 'हैंग' होने का सामना कर सकता है। Kotlin में कार्य कतारें केवल एक अमूर्तता नहीं हैं, बल्कि एक शक्तिशाली उपकरण हैं जो थ्रेड्स की संख्या और प्राथमिकताओं को नियंत्रित करते हुए कार्य को सही क्रम में व्यवस्थित करने में मदद करता है।

इस लेख में, हम Kotlin में कार्य कतारों को लागू करने के व्यावहारिक दृष्टिकोणों पर चर्चा करेंगे: क्लासिक ThreadPoolExecutor से लेकर उनके लचीले डिस्पैचर्स के साथ कोरूटीन तक। आप देखेंगे कि वास्तविक परियोजनाओं में इन तकनीकों को कैसे लागू किया जाए, और आपको तैयार कोड उदाहरण मिलेंगे।

1. क्लासिक दृष्टिकोण: ThreadPoolExecutor और BlockingQueue

स्टैंडर्ड जावा लाइब्रेरी (और Kotlin, एक JVM भाषा के रूप में) शक्तिशाली क्लास ThreadPoolExecutor प्रदान करती है। यह थ्रेड्स के पूल को प्रबंधित करता है और प्रतीक्षा कार्यों को संग्रहीत करने के लिए आंतरिक ब्लॉकिंग कतार का उपयोग करता है।

निश्चित संख्या में थ्रेड्स के साथ कतार बनाना

सबसे सरल मामला थ्रेड्स की निश्चित संख्या वाला पूल है। जो कार्य तुरंत निष्पादित नहीं किए जा सकते, वे LinkedBlockingQueue कतार में रखे जाते हैं।

import java.util.concurrent.Executors\nimport java.util.concurrent.TimeUnit\n\nfun main() {\n    val executor = Executors.newFixedThreadPool(3)\n\n    for (i in 1..10) {\n        executor.submit {\n            println("कार्य $i थ्रेड ${Thread.currentThread().name} में निष्पादित हो रहा है")\n            Thread.sleep(1000)\n        }\n    }\n\n    executor.shutdown()\n    executor.awaitTermination(1, TimeUnit.MINUTES)\n    println("सभी कार्य पूर्ण हो गए")\n}\n

यह कोड एक बुनियादी कतार प्रदर्शित करता है: कार्य पूल में भेजे जाते हैं, और यदि सभी थ्रेड व्यस्त हैं, तो वे कतार में प्रतीक्षा करते हैं।

प्राथमिकता कतार: PriorityBlockingQueue

कभी-कभी अत्यावश्यक कार्यों को दूसरों से पहले निष्पादित करने की आवश्यकता होती है। इसके लिए हम कस्टम कम्पेरेटर के साथ PriorityBlockingQueue का उपयोग करते हैं।

import java.util.concurrent.PriorityBlockingQueue\nimport java.util.concurrent.ThreadPoolExecutor\nimport java.util.concurrent.TimeUnit\n\ndata class PriorityTask(val priority: Int, val name: String) : Comparable<PriorityTask> {\n    override fun compareTo(other: PriorityTask): Int = other.priority - this.priority\n}\n\nfun main() {\n    val queue = PriorityBlockingQueue<Runnable>(10) { r1, r2 ->\n        val t1 = (r1 as PriorityTaskWrapper).task\n        val t2 = (r2 as PriorityTaskWrapper).task\n        t1.compareTo(t2)\n    }\n\n    val executor = ThreadPoolExecutor(2, 4, 1, TimeUnit.SECONDS, queue)\n\n    class PriorityTaskWrapper(val task: PriorityTask, val action: () -> Unit) : Runnable {\n        override fun run() = action()\n    }\n\n    for (i in 1..5) {\n        val priority = if (i % 2 == 0) 10 else 1\n        executor.submit(PriorityTaskWrapper(PriorityTask(priority, "कार्य $i")) {\n            println("निष्पादित हो रहा है: ${PriorityTask(priority, "कार्य $i")}")\n            Thread.sleep(500)\n        })\n    }\n\n    executor.shutdown()\n    executor.awaitTermination(1, TimeUnit.MINUTES)\n}\n

यहाँ priority = 10 वाले कार्य priority = 1 वाले कार्यों से पहले निष्पादित होंगे, भले ही वे बाद में जोड़े गए हों।

2. कोरूटीन (kotlinx.coroutines) के साथ कार्य कतारें

आधुनिक Kotlin कोरूटीन प्रदान करता है - हल्के थ्रेड जो थ्रेड्स के प्रत्यक्ष प्रबंधन के बिना एसिंक्रोनस कतारें बनाने की अनुमति देते हैं। मुख्य उपकरण Channel और Dispatchers हैं।

Channel के माध्यम से सरल कतार

Channel कोरूटीन के लिए ब्लॉकिंग कतार का एक एनालॉग है। यह कोरूटीन के बीच कार्यों को सुरक्षित रूप से स्थानांतरित करने की अनुमति देता है।

import kotlinx.coroutines.*\nimport kotlinx.coroutines.channels.Channel\n\nsuspend fun processTas