कोटलिन में कोराटिन पैटर्न और एंटीपैटर्न

मैंने कुछ चीजों के बारे में लिखने का फैसला किया, जो कि मेरी राय में, कोटलिन कोरटाइन का उपयोग करते समय नहीं किया जाना चाहिए।

CoroutineScope में अतुल्यकालिक कॉल लपेटें या अपवादों को संभालने के लिए SupervisorJob का उपयोग करें

यदि कोई अपवाद async ब्लॉक में हो सकता है, तो try/catch पर भरोसा न try/catch ।

 val job: Job = Job() val scope = CoroutineScope(Dispatchers.Default + job) // may throw Exception fun doWork(): Deferred<String> = scope.async { ... } // (1) fun loadData() = scope.launch { try { doWork().await() // (2) } catch (e: Exception) { ... } } 

उपरोक्त उदाहरण में, doWork फ़ंक्शन एक नया coroutine (1) शुरू करता है, जो एक doWork अपवाद को फेंक सकता है। यदि आप एक try/catch (2) try/catch साथ doWork को लपेटने की try/catch , तो एप्लिकेशन अभी भी दुर्घटनाग्रस्त हो जाएगा।

ऐसा इसलिए है क्योंकि नौकरी के किसी भी बच्चे के घटक की विफलता उसके माता-पिता की तत्काल विफलता की ओर ले जाती है।

त्रुटि से बचने का एक तरीका SupervisorJob (1) का उपयोग करना है।

बाल घटक के निष्पादन में विफलता या रद्द करने से माता-पिता की विफलता नहीं होगी और अन्य घटकों को प्रभावित नहीं किया जाएगा।

 val job = SupervisorJob() // (1) val scope = CoroutineScope(Dispatchers.Default + job) // may throw Exception fun doWork(): Deferred<String> = scope.async { ... } fun loadData() = scope.launch { try { doWork().await() } catch (e: Exception) { ... } } 

नोट : यह केवल तभी काम करेगा जब आप SupervisorJob साथ अपने अतुल्यकालिक कोरटाइन कॉल को स्पष्ट रूप से शुरू करेंगे। इस प्रकार, नीचे दिया गया कोड अभी भी आपके एप्लिकेशन को क्रैश कर देगा, क्योंकि async मूल कोराउटाइन (1) के हिस्से के रूप में चलता है।

 val job = SupervisorJob() val scope = CoroutineScope(Dispatchers.Default + job) fun loadData() = scope.launch { try { async { // (1) // may throw Exception }.await() } catch (e: Exception) { ... } } 

दुर्घटना से बचने का एक और तरीका, जो अधिक बेहतर है, coroutineScope (1) में coroutineScope लपेटना है। अब, जब कोई अपवाद async अंदर होता है, तो यह बाहरी क्षेत्र को स्पर्श किए बिना, इस क्षेत्र में बनाए गए अन्य सभी कोरआउट को रद्द कर देता है। (2)

 val job = SupervisorJob() val scope = CoroutineScope(Dispatchers.Default + job) // may throw Exception fun doWork(): Deferred<String> = coroutineScope { // (1) async { ... } } fun loadData() = scope.launch { // (2) try { doWork().await() } catch (e: Exception) { ... } } 

इसके अलावा, आप async ब्लॉक के अंदर अपवादों को संभाल सकते हैं।

रूट कोरटाइन के लिए मुख्य प्रबंधक का उपयोग करें

यदि आपको अपनी रूट कोरआउट के अंदर बैकग्राउंड वर्क करने और यूजर इंटरफेस अपडेट करने की आवश्यकता है, तो इसे मुख्य डिस्पैचर का उपयोग करके शुरू करें।

 val scope = CoroutineScope(Dispatchers.Default) // (1) fun login() = scope.launch { withContext(Dispatcher.Main) { view.showLoading() } // (2) networkClient.login(...) withContext(Dispatcher.Main) { view.hideLoading() } // (2) } 

उपरोक्त उदाहरण में, हम CoroutineScope (1) में CoroutineScope डिस्पैचर का उपयोग करके रूट कोरआउट शुरू करते हैं। इस दृष्टिकोण के साथ, हर बार जब हमें उपयोगकर्ता इंटरफ़ेस को अपडेट करने की आवश्यकता होती है, तो हमें संदर्भ (2) स्विच करना होगा।

ज्यादातर मामलों में, मुख्य डिस्पैचर के साथ तुरंत CoroutineScope बनाने के लिए बेहतर है, जिससे कोड का सरलीकरण और कम स्पष्ट संदर्भ स्विचिंग हो जाएगा।

 val scope = CoroutineScope(Dispatchers.Main) fun login() = scope.launch { view.showLoading() withContext(Dispatcher.IO) { networkClient.login(...) } view.hideLoading() } 

अनावश्यक एसिंक्स / वेट का उपयोग करने से बचें

यदि आप async फ़ंक्शन का उपयोग करते हैं और तुरंत await , तो आपको ऐसा करना बंद कर देना चाहिए।

 launch { val data = async(Dispatchers.Default) { /* code */ }.await() } 

यदि आप withContext के संदर्भ को स्विच करना चाहते हैं और तुरंत माता-पिता के withContext को निलंबित कर देते हैं, तो इसके लिए withContext सबसे बेहतर तरीका है।

 launch { val data = withContext(Dispatchers.Default) { /* code */ } } 

प्रदर्शन के संदर्भ में, यह इतनी बड़ी समस्या नहीं है (यहां तक ​​कि यह मानते हुए कि async नौकरी के लिए एक नया coroutine बनाता है), लेकिन शब्दार्थ async तात्पर्य है कि आप पृष्ठभूमि में कई coroutines चलाना चाहते हैं और उसके बाद ही उनकी प्रतीक्षा करें।

नौकरी रद्द करने से बचें

यदि आपको कोरआउट रद्द करने की आवश्यकता है, तो नौकरी रद्द न करें।

 class WorkManager { val job = SupervisorJob() val scope = CoroutineScope(Dispatchers.Default + job) fun doWork1() { scope.launch { /* do work */ } } fun doWork2() { scope.launch { /* do work */ } } fun cancelAllWork() { job.cancel() } } fun main() { val workManager = WorkManager() workManager.doWork1() workManager.doWork2() workManager.cancelAllWork() workManager.doWork1() // (1) } 

ऊपर दिए गए कोड के साथ समस्या यह है कि जब हम नौकरी को रद्द करते हैं, तो हम इसे पूर्ण स्थिति में रख देते हैं। पूर्ण की गई नौकरी के हिस्से के रूप में लॉन्च किए गए कोरआउट को निष्पादित नहीं किया जाएगा (1)।

यदि आप एक विशिष्ट क्षेत्र में सभी cancelChildren को पूर्ववत करना चाहते हैं, तो आप cancelChildren फ़ंक्शन का उपयोग कर सकते हैं। इसके अलावा, व्यक्तिगत नौकरियों (2) को रद्द करने की क्षमता प्रदान करना अच्छा अभ्यास है।

 class WorkManager { val job = SupervisorJob() val scope = CoroutineScope(Dispatchers.Default + job) fun doWork1(): Job = scope.launch { /* do work */ } // (2) fun doWork2(): Job = scope.launch { /* do work */ } // (2) fun cancelAllWork() { scope.coroutineContext.cancelChildren() // (1) } } fun main() { val workManager = WorkManager() workManager.doWork1() workManager.doWork2() workManager.cancelAllWork() workManager.doWork1() } 

अंतर्निहित डिस्पैचर का उपयोग करके पॉज़ फ़ंक्शन लिखने से बचें

suspend फ़ंक्शन न लिखें, जिसका निष्पादन विशेष रूप से कोरआउट प्रबंधक पर निर्भर करेगा।

 suspend fun login(): Result { view.showLoading() val result = withContext(Dispatcher.IO) { someBlockingCall() } view.hideLoading() return result } 

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

 launch(Dispatcher.Main) { // (1)    val loginResult = login() ... } launch(Dispatcher.Default) { // (2)   val loginResult = login() ... } 

CalledFromWrongThreadException: केवल स्रोत थ्रेड जिसने व्यू घटकों का पदानुक्रम बनाया था, वे उन तक पहुँच सकते हैं।

अपना निलंबन फ़ंक्शन बनाएं ताकि इसे किसी भी कोरआउट प्रबंधक से निष्पादित किया जा सके।

 suspend fun login(): Result = withContext(Dispatcher.Main) { view.showLoading() val result = withContext(Dispatcher.IO) { someBlockingCall() } view.hideLoading() return result } 

अब हम किसी भी डिस्पैचर से अपने लॉगिन फ़ंक्शन को कॉल कर सकते हैं।

 launch(Dispatcher.Main) { // (1) no crash val loginResult = login() ... } launch(Dispatcher.Default) { // (2) no crash ether val loginResult = login() ... } 

वैश्विक दायरे का उपयोग करने से बचें

यदि आप अपने Android एप्लिकेशन में हर जगह GlobalScope उपयोग करते हैं, तो आपको ऐसा करना बंद कर देना चाहिए।

 GlobalScope.launch { // code } 

वैश्विक स्कोप का उपयोग शीर्ष-स्तरीय कोरटाइन्स को लॉन्च करने के लिए किया जाता है जो आवेदन के पूरे जीवन में चलते हैं और समय से पहले रद्द नहीं किए जाते हैं।

एप्लिकेशन कोड को आमतौर पर एप्लिकेशन- विशिष्ट कॉरटाइनस्स्कोप का उपयोग करना चाहिए, इसलिए ग्लोबलस्कैप में एसिक्स या लॉन्च का उपयोग करना अत्यधिक हतोत्साहित करता है।

एंड्रॉइड में, कोरटाइन को एक गतिविधि, फ्रैगमेंट, व्यू या व्यूमॉडल के जीवन चक्र तक आसानी से सीमित किया जा सकता है।

 class MainActivity : AppCompatActivity(), CoroutineScope { private val job = SupervisorJob() override val coroutineContext: CoroutineContext get() = Dispatchers.Main + job override fun onDestroy() { super.onDestroy() coroutineContext.cancelChildren() } fun loadData() = launch { // code } }