Kotlin समवर्तीता: थ्रेड्स, गोरूटीन्स और शुरुआती लोगों के लिए async/await

Kotlin बनाम Python: कौन किससे बेहतर? समवर्तीता की लड़ाई

यदि आप PythonLib पर यह सामग्री पढ़ रहे हैं, तो संभवतः आप Python और इसके GIL (Global Interpreter Lock) से पहले से ही परिचित हैं, जो मल्टीथ्रेडिंग को सिरदर्द बना देता है। आप threading लिखते हैं, गति में वृद्धि की उम्मीद करते हैं, और पाते हैं… लॉक के स्वाद के साथ सिंक्रोनस कोड। परिचित लगता है?

Kotlin की दुनिया में आपका स्वागत है! यह एक ऐसी भाषा है जिसने तय किया: "चलो समवर्तीता को सुविधाजनक, तेज़ और दर्द रहित बनाते हैं"। इस लेख में हम Kotlin में समवर्तीता के तीन दृष्टिकोणों पर चर्चा करेंगे: क्लासिक थ्रेड्स, आधुनिक गोरूटीन्स और शक्तिशाली जोड़ी async/await। आप सीखेंगे कि ऐसा एसिंक्रोनस कोड कैसे लिखें जो दिमाग न घुमाए, और Kotlin बैकएंड और Android डेवलपमेंट के लिए एक बेहतरीन विकल्प क्यों है।

1. Kotlin में थ्रेड्स: पुराना दोस्त दो नए से बेहतर?

आधार से शुरू करते हैं। Kotlin में थ्रेड्स, Java के समान ही थ्रेड्स हैं। Kotlin JVM पर चलता है, इसलिए आपके पास java.lang.Thread की पूरी शक्ति तक पहुंच है। लेकिन ईमानदारी से कहें तो: थ्रेड्स बिना एयरबैग के कार चलाने जैसे हैं। काम करता है, लेकिन डर लगता है।

Kotlin में थ्रेड कैसे बनाएं?

सबसे आसान तरीका:

fun main() {\n    thread {\n        println("थ्रेड से नमस्ते: ${Thread.currentThread().name}")\n    }\n    println("मुख्य थ्रेड: ${Thread.currentThread().name}")\n}

परिचित लगता है, है ना? लेकिन एक बारीकी है: थ्रेड्स भारी होते हैं। प्रत्येक थ्रेड एक अलग सिस्टम संसाधन है। यदि आप 10,000 थ्रेड बनाते हैं, तो आपका प्रोग्राम या तो OutOfMemoryError के साथ क्रैश हो जाएगा, या Windows 95 वाले पुराने कंप्यूटर की तरह धीमा हो जाएगा।

थ्रेड्स की समस्याएं:

\n
• उच्च मेमोरी खपत — प्रत्येक थ्रेड स्टैक (~1 MB) आरक्षित करता है।
\n
• सिंक्रोनाइज़ेशन की जटिलता — लॉक, डेडलॉक, रेस कंडीशन। Java में synchronized याद करें और रोएं।
\n
• कॉन्टेक्स्ट स्विचिंग — OS थ्रेड्स के बीच स्विच करने में समय बर्बाद करता है।
\n

छोटे प्रोजेक्ट्स के लिए थ्रेड्स काम करेंगे। लेकिन यदि आप एक उच्च-लोड सेवा या हजारों समानांतर कार्यों वाला एप्लिकेशन बना रहे हैं, तो गोरूटीन्स की ओर देखने का समय आ गया है।

2. Kotlin में गोरूटीन्स: पंख की तरह हल्के

गोरूटीन्स (coroutines) "स्टेरॉयड पर थ्रेड्स" हैं। वे सिस्टम थ्रेड्स से बंधे नहीं होते हैं और OS की भागीदारी के बिना एक ही थ्रेड पर कार्यों के बीच स्विच कर सकते हैं। जटिल लगता है? वास्तव में, यह सरल और सुरुचिपूर्ण है।

पहली गोरूटीन

गोरूटीन्स के साथ काम करने के लिए आपको kotlinx-coroutines-core डिपेंडेंसी की आवश्यकता होगी। लेकिन यदि आप Kotlin 1.3+ का उपयोग कर रहे हैं, तो यह पहले से ही अंतर्निहित है।

import kotlinx.coroutines.*\n\nfun main() = runBlocking {\n    launch {\n        delay(1000L)\n        println("देरी के बाद दुनिया!")\n    }\n    println("नमस्ते,")\n}

यहाँ क्या हो रहा है?

\n
• runBlocking — मुख्य थ्रेड को तब तक ब्लॉक करता है जब तक अंदर की सभी गोरूटीन्स पूरी नहीं हो जातीं। सीखने के लिए ठीक है, प्रोडक्शन के लिए सावधानी से उपयोग करें।
\n
• launch — एक नई गोरूटीन शुरू करता है। यह थ्रेड को ब्लॉक नहीं करता, बल्कि delay पर रुक जाता है।
\n
• delay — Thread.sleep() का एनालॉग, लेकिन नॉन-ब्लॉकिंग। गोरूटीन बस "सो जाती है" और अन्य कार्यों के लिए थ्रेड को मुक्त कर देती है।
\n

परिणाम: पहले "नमस्ते," प्रिंट होता है, और एक सेकंड बाद "देरी के बाद दुनिया!"। बिना ब्लॉकिंग के, बिना अतिरिक्त थ्रेड्स के।

गोरूटीन्स थ्रेड्स से बेहतर क्यों हैं?

\n
• हल्कापन — दस लाख गोरूटीन्स? आसान! वे अलग थ्रेड नहीं बनातीं।
\n
• निलंबन (suspension) — गोरूटीन किसी भी क्षण रुक सकती है और बाद में जारी रख सकती है।
\n
• संरचित समवर्तीता — गोरूटीन्स एक स्कोप में रहती हैं और यदि स्कोप समाप्त होता है तो स्वचालित रूप से रद्द हो जाती हैं।
\n

डिस्पैचर्स (Dispatchers