संपर्क : @ivanzamzam

lifecycleScope — यह क्या है, Lifecycle से जुड़ाव और Android में काम करना

ज्ञान
Kotlin विशिष्टताएँ
lifecycleScope
लेखक: IT Sectr प्रकाशित: 2026-06-23 पढ़ने का समय: 9 मिनट

lifecycleScope — androidx.lifecycle लाइब्रेरी से एक अंतर्निर्मित CoroutineScope है, जो Activity, Fragment या किसी भी LifecycleOwner के जीवनचक्र से जुड़ा होता है और घटक के नष्ट होने पर स्वचालित रूप से कोरूटीन को रद्द कर देता है। Google Android Developers, 2025 के अनुसार, lifecycleScope Activity या Fragment के नष्ट होने के बाद कोड निष्पादित करने के जोखिम के बिना UI परत से जुड़े कोरूटीन को सुरक्षित रूप से चलाने की अनुमति देता है। LifecycleOwner के DESTROYED स्थिति में जाने पर scope स्वचालित रूप से रद्द हो जाता है।

मुख्य बातें

  • lifecycleScope — lifecycle-runtime-ktx से CoroutineScope, Lifecycle की DESTROYED स्थिति पर रद्द होता है
  • lifecycleScope.launch — कोरूटीन लॉन्च करता है जो LifecycleOwner के नष्ट होने पर स्वचालित रूप से रद्द हो जाता है
  • launchWhenStarted / launchWhenResumed — पुराने तरीके, repeatOnLifecycle द्वारा प्रतिस्थापित
  • repeatOnLifecycle — Lifecycle की विशिष्ट स्थिति का अनुसरण करने वाले कोरूटीन लॉन्च करने के लिए आधुनिक API
  • Dispatchers.Main.immediate — lifecycleScope के लिए डिफ़ॉल्ट डिस्पैचर

Android में lifecycleScope क्या है?

lifecycleScope LifecycleOwner इंटरफ़ेस (Activity, Fragment, Service) पर एक एक्सटेंशन प्रॉपर्टी है जो घटक के पूर्ण जीवनचक्र से जुड़ा एक तैयार CoroutineScope प्रदान करती है। जब LifecycleOwner DESTROYED स्थिति तक पहुँचता है, तो lifecycleScope स्वचालित रूप से सभी सक्रिय कोरूटीन को रद्द कर देता है।

kotlin 
// In Fragment or Activity
lifecycleScope.launch {
    delay(1000)
    showSnackbar("नमस्ते!")
}

viewModelScope के विपरीत, lifecycleScope हर बार LifecycleOwner के नष्ट होने पर रद्द होता है — जिसमें स्क्रीन रोटेशन भी शामिल है। यह इसे उन कार्यों के लिए आदर्श बनाता है जो केवल तब तक चलने चाहिए जब तक कोई विशिष्ट स्क्रीन दिखाई दे रही हो।

lifecycleScope कहाँ उपलब्ध है

lifecycleScope हर उस जगह उपलब्ध है जहाँ LifecycleOwner है:

  • Activity — AppCompatActivity LifecycleOwner को इनहेरिट करता है
  • Fragment — Fragment LifecycleOwner को इनहेरिट करता है
  • LifecycleService — जीवनचक्र वाली सेवा
  • ProcessLifecycleOwner — पूरे एप्लिकेशन का जीवनचक्र
  • कस्टम LifecycleOwner — कोई भी ऑब्जेक्ट जो LifecycleOwner को लागू करता है

lifecycleScope कैसे काम करता है: Lifecycle और स्वचालित रद्दीकरण

lifecycleScope की स्वचालित रद्दीकरण तंत्र Lifecycle ईवेंट की सदस्यता पर आधारित है। जब Lifecycle CREATED से नीचे DESTROYED पर जाता है, तो scope रद्द हो जाता है।

Lifecycle स्थितियाँ

स्थितिविवरणScope सक्रिय
CREATEDLifecycleOwner बनाया गया, onCreate निष्पादित हुआहाँ
STARTEDLifecycleOwner दिखाई दे रहा है (onStart)हाँ
RESUMEDLifecycleOwner अग्रभूमि में है (onResume)हाँ
DESTROYEDLifecycleOwner नष्ट हो गया (onDestroy)नहीं (scope रद्द)

lifecycleScope की आंतरिक संरचना

lifecycleScope को CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) के रूप में बनाया जाता है और Lifecycle के अंदर संग्रहीत किया जाता है। जब Lifecycle DESTROYED स्थिति में जाता है, तो scope.cancel() कॉल किया जाता है। यह तंत्र LifecycleEventObserver के माध्यम से लागू किया जाता है, जो scope तक पहली पहुँच पर जीवनचक्र ईवेंट की सदस्यता लेता है।

रोटेशन पर व्यवहार

जब स्क्रीन घुमाई जाती है, तो Activity नष्ट (onDestroy) होती है और फिर से बनाई जाती है। lifecycleScope पुरानी Activity के साथ रद्द हो जाता है, और नई Activity के लिए scope का एक नया उदाहरण बनाया जाता है। यह viewModelScope से मूलभूत अंतर है, जो रोटेशन पर बचा रहता है।

lifecycleScope API: launch, launchWhen और repeatOnLifecycle

lifecycle लाइब्रेरी lifecycleScope के माध्यम से कोरूटीन लॉन्च करने के कई तरीके प्रदान करती है। आइए पुराने तरीकों से आधुनिक API तक के विकास को देखें।

lifecycleScope.launch — बुनियादी लॉन्च

सबसे सरल तरीका है lifecycleScope.launch { ... }। कोरूटीन तुरंत शुरू होता है और DESTROYED पर रद्द हो जाता है। हालाँकि, यह UI दिखाई न देने पर भी कोड निष्पादित कर सकता है (उदाहरण के लिए, onStop के बाद पृष्ठभूमि में)। यह हमेशा वांछनीय नहीं होता।

पुराने तरीके: launchWhenCreated / launchWhenStarted / launchWhenResumed

ये तरीके Lifecycle के निर्दिष्ट स्थिति से नीचे जाने पर कोरूटीन निष्पादन को रोक देते थे और वापस आने पर फिर से शुरू करते थे। हालाँकि, उन्हें lifecycle-runtime-ktx 2.6.0 में @Deprecated चिह्नित किया गया था क्योंकि:

  • वे कोरूटीन को रद्द नहीं करते थे — केवल रोकते थे
  • वे मेमोरी खपत करने वाले लटके हुए कोरूटीन के संचय का कारण बनते थे
  • वे तेज़ स्थिति स्विचिंग पर रेस कंडीशन बनाते थे

आधुनिक API: repeatOnLifecycle

repeatOnLifecycle Google द्वारा जीवनचक्र के साथ सिंक्रनाइज़ कोरूटीन लॉन्च करने का अनुशंसित तरीका है। यह हर बार Lifecycle के निर्दिष्ट स्थिति तक पहुँचने पर कोरूटीन को रद्द और पुनरारंभ करता है।

kotlin 
lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        viewModel.uiState.collect { state ->
            updateUI(state)
        }
    }
}

repeatOnLifecycle को पास किया गया कोरूटीन तब शुरू होता है जब Lifecycle STARTED तक पहुँचता है और जब वह STARTED से नीचे जाता है तो रद्द हो जाता है। STARTED पर वापस आने पर, कोरूटीन फिर से शुरू होता है। यह सुरक्षित और कुशल है — कोई भी कोरूटीन लटका नहीं रहता।

flowWithLifecycle — Flow के लिए

जीवनचक्र जागरूकता के साथ Flow से डेटा संग्रह करने के लिए, flowWithLifecycle ऑपरेटर मौजूद है। यह Lifecycle स्थिति बदलने पर स्वचालित रूप से संग्रह रोकता और फिर से शुरू करता है:

kotlin 
viewModel.uiState
    .flowWithLifecycle(lifecycle, Lifecycle.State.STARTED)
    .onEach { state -> updateUI(state) }
    .launchIn(lifecycleScope)

flowWithLifecycle ऑपरेटर UI परत में Flow की सुरक्षित सदस्यता लेने का सबसे संक्षिप्त तरीका है।

lifecycleScope उपयोग उदाहरण

आइए Kotlin में Android एप्लिकेशन में lifecycleScope के उपयोग के तीन वास्तविक परिदृश्य देखें।

उदाहरण 1: केवल स्क्रीन दिखाई देने पर स्थान अपडेट की सदस्यता लेना

kotlin 
class MapFragment : Fragment() {

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                locationProvider.observeLocation().collect { loc ->
                    updateMapMarker(loc)
                }
            }
        }
    }
}

कोरूटीन तब शुरू होता है जब फ़्रैगमेंट दिखाई देने लगता है (STARTED) और स्क्रीन छोड़ने पर रद्द हो जाता है (STOPPED)। यदि उपयोगकर्ता किसी अन्य एप्लिकेशन पर स्विच करता है, तो स्थान अपडेट बैटरी खर्च नहीं करते।

उदाहरण 2: फ़्रैगमेंट शुरू होने पर एनिमेशन चलाना

kotlin 
lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.RESUMED) {
        animateFadeIn(titleView)
        delay(200)
        animateSlideUp(contentView)
    }
}

एनिमेशन केवल तभी चलता है जब फ़्रैगमेंट अग्रभूमि में हो (RESUMED)। यदि उपयोगकर्ता एनिमेशन के दौरान एप्लिकेशन को छोटा कर देता है, तो कोरूटीन रद्द हो जाता है, और वापस लौटने पर एनिमेशन फिर से शुरू हो जाता है।

उदाहरण 3: दिखाई देने वाली स्क्रीन पर आवधिक डेटा सिंक

kotlin 
lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        while (isActive) {
            syncData()
            delay(30_000L)
        }
    }
}

डेटा हर 30 सेकंड में सिंक होता है, लेकिन केवल तब जब स्क्रीन दिखाई दे रही हो। isActive जाँचता है कि कोरूटीन रद्द हुआ है या नहीं, जो स्क्रीन छोड़ने पर लूप से सुरक्षित निकास प्रदान करता है।

lifecycleScope बनाम viewModelScope: उपयोग परिदृश्य

दोनों scope जीवनचक्र से जुड़े हैं, लेकिन इसके विभिन्न पहलुओं से। अंतर को समझना Android एप्लिकेशन की सही आर्किटेक्चर के लिए महत्वपूर्ण है।

मुख्य अंतर

viewModelScope ViewModel से जुड़ा है, जो स्क्रीन रोटेशन पर बचा रहता है। lifecycleScope LifecycleOwner (Activity/Fragment) से जुड़ा है, जो रोटेशन पर नष्ट और पुनर्निर्मित होता है। यह उनके उपयोग परिदृश्यों को निर्धारित करता है।

lifecycleScope का उपयोग कब करें

  • सिस्टम ईवेंट की सदस्यता (स्थान, सेंसर, कैमरा)
  • किसी विशिष्ट स्क्रीन से जुड़े एनिमेशन और UI प्रभाव
  • स्क्रीन दृश्यता के आधार पर खंडित डेटा लोडिंग
  • वे कार्य जो स्क्रीन छोड़ने पर बंद हो जाने चाहिए

viewModelScope का उपयोग कब करें

  • Repository से डेटा लोड करना
  • व्यावसायिक तर्क जो रोटेशन पर बचा रहना चाहिए
  • डेटा कैशिंग और प्रसंस्करण
  • कोई भी कार्य जिसका परिणाम रोटेशन के बाद चाहिए

संयुक्त उपयोग

व्यवहार में, दोनों scope का संयोजन आम है: viewModelScope डेटा लोड करता है और स्थिति प्रबंधित करता है, जबकि lifecycleScope जीवनचक्र जागरूकता के साथ ViewModel से Flow की सदस्यता लेता है। जिम्मेदारियों का यह पृथक्करण आधुनिक Android विकास में सर्वोत्तम अभ्यास माना जाता है।

lifecycleScope के साथ काम करते समय सामान्य गलतियाँ

आइए lifecycleScope का उपयोग करते समय डेवलपर्स द्वारा की जाने वाली चार सबसे सामान्य गलतियों को देखें।

गलती 1: डेटा लोड करने के लिए viewModelScope के बजाय lifecycleScope का उपयोग करना

यदि आप lifecycleScope.launch में डेटा लोडिंग शुरू करते हैं, तो स्क्रीन रोटेशन पर कोरूटीन रद्द हो जाएगा और डेटा फिर से लोड करना होगा। लंबे समय तक चलने वाले कार्यों के लिए viewModelScope का उपयोग करें। lifecycleScope केवल UI-बाउंड कार्यों के लिए है।

गलती 2: repeatOnLifecycle के बिना Flow संग्रह करना

lifecycleScope.launch के अंदर सीधे viewModel.someFlow.collect { ... } कॉल करना स्क्रीन दिखाई न देने पर भी डेटा संग्रह जारी रखता है। इससे पृष्ठभूमि में UI अपडेट और अनावश्यक ओवरहेड हो सकता है। हमेशा repeatOnLifecycle या flowWithLifecycle का उपयोग करें।

गलती 3: स्क्रीन छोड़ने पर रद्दीकरण के बारे में भूलना

हालाँकि lifecycleScope DESTROYED पर रद्द हो जाता है, लेकिन अचानक रद्द होने पर सस्पेंड पॉइंट के बाद का कोड निष्पादित नहीं हो सकता है। जब तक आप NonCancellable का उपयोग नहीं कर रहे हैं, तब तक सस्पेंड कॉल के बाद पोस्ट-कोड निष्पादन पर भरोसा न करें।

गलती 4: repeatOnLifecycle के बजाय पुराने launchWhenStarted का उपयोग करना

launchWhenStarted और इसके समकक्ष कोरूटीन को रद्द नहीं करते, केवल रोकते हैं। यदि स्क्रीन कई बार अग्रभूमि और पृष्ठभूमि के बीच स्विच करती है, तो कोरूटीन स्थगित कॉल जमा करता है। repeatOnLifecycle पर स्विच करें — Lifecycle के साथ सिंक्रनाइज़ करने का यह एकमात्र सही तरीका है।

अक्सर पूछे जाने वाले प्रश्न

lifecycleScope और GlobalScope में क्या अंतर है?

lifecycleScope LifecycleOwner के नष्ट होने पर स्वचालित रूप से रद्द हो जाता है। GlobalScope एप्लिकेशन के पूरे जीवनकाल तक जीवित रहता है। lifecycleScope में कोरूटीन घटक के नष्ट होने के बाद UI अपडेट नहीं कर सकता, GlobalScope में कर सकता है, जिससे क्रैश होते हैं। UI परत में हमेशा lifecycleScope का उपयोग करें।

क्या ViewModel में lifecycleScope का उपयोग किया जा सकता है?

नहीं, ViewModel LifecycleOwner नहीं है, इसलिए इसमें lifecycleScope उपलब्ध नहीं है। ViewModel viewModelScope का उपयोग करता है। यदि कोड दोनों संदर्भों में चलना चाहिए, तो लॉजिक को suspend फ़ंक्शन के साथ use case या repository में निकालें।

repeatOnLifecycle को कई बार कॉल करने पर क्या होता है?

repeatOnLifecycle का प्रत्येक कॉल एक नया कोरूटीन बनाता है जो निर्दिष्ट Lifecycle स्थिति तक पहुँचने पर ब्लॉक चलाता है। यदि repeatOnLifecycle को एक ही स्थिति के लिए दो बार कॉल किया जाता है, तो दोनों ब्लॉक स्वतंत्र रूप से चलेंगे। आमतौर पर onViewCreated में एक कॉल पर्याप्त है।

क्या lifecycleScope के लिए कस्टम Dispatcher सेट किया जा सकता है?

आप सीधे lifecycleScope डिस्पैचर को नहीं बदल सकते — यह Dispatchers.Main.immediate का उपयोग करता है। कोरूटीन ब्लॉक के अंदर, आप withContext के माध्यम से किसी अन्य डिस्पैचर पर स्विच कर सकते हैं। परीक्षण के लिए, LifecycleOwner के साथ TestDispatcher का उपयोग करें।

क्या lifecycleScope onPause या onDestroy में रद्द होता है?

lifecycleScope LifecycleOwner के DESTROYED स्थिति (onDestroy के बाद) में जाने पर रद्द होता है। सरल lifecycleScope.launch कॉल onPause या onStop में रद्द नहीं होते। पृष्ठभूमि में जाने पर रोकने के लिए, repeatOnLifecycle(STARTED) या repeatOnLifecycle(RESUMED) का उपयोग करें।

सारांश

  • lifecycleScope — LifecycleOwner से जुड़ा CoroutineScope, DESTROYED पर LifecycleEventObserver के माध्यम से स्वचालित रूप से रद्द होता है
  • Dispatchers.Main.immediate — डिफ़ॉल्ट डिस्पैचर, अनावश्यक स्विचिंग के बिना सुरक्षित UI अपडेट सुनिश्चित करता है
  • repeatOnLifecycle — निर्दिष्ट Lifecycle स्थिति पर स्वचालित रद्दीकरण और पुनरारंभ के साथ कोरूटीन लॉन्च करने के लिए आधुनिक API
  • flowWithLifecycle — जीवनचक्र जागरूकता के साथ UI से सुरक्षित Flow संग्रह के लिए ऑपरेटर
  • launchWhenStarted पुराना हो गया — रोकने के बजाय, repeatOnLifecycle का उपयोग करें जो कोरूटीन को रोकने के बजाय रद्द करता है
  • lifecycleScope बनाम viewModelScope — lifecycleScope UI कार्यों (एनिमेशन, स्थान) के लिए, viewModelScope डेटा और व्यावसायिक तर्क के लिए
  • स्क्रीन रोटेशन — lifecycleScope रोटेशन पर रद्द होता है, viewModelScope बचा रहता है; कार्य के अनुसार scope चुनें

हम एक मोबाइल एप्लिकेशन टर्नकी विकसित करेंगे

IT Sectr 2017 से स्टार्टअप और व्यवसायों के लिए iOS और Android एप्लिकेशन बनाता है। हम आपको सलाह देंगे और सर्वोत्तम समाधान प्रस्तावित करेंगे।

परियोजना पर चर्चा करें

यह भी पढ़ें

viewModelScope: यह क्या है, ViewModel से जुड़ाव और Android में कैसे काम करता है →
Lambda: यह क्या है, सिंटैक्स और Kotlin में यह कैसे काम करता है →
स्कोप फ़ंक्शंस — ये क्या हैं, प्रकार और Kotlin में ये कैसे काम करते हैं →
फ़ीचर क्रीप इन डेवलपमेंट — यह क्या है, कारण और इससे कैसे निपटें →
डेवलपमेंट में ट्रैश कोड — यह क्या है, संकेत और कैसे साफ करें →