प्रोसेस और ऐप्लिकेशन का लाइफ़साइकल

ज़्यादातर मामलों में, हर Android ऐप्लिकेशन अपनी Linux प्रोसेस में चलता है. यह प्रोसेस, ऐप्लिकेशन के लिए तब बनाई जाती है, जब उसके कुछ कोड को चलाने की ज़रूरत होती है. यह प्रोसेस तब तक चलती रहती है, जब तक सिस्टम को अन्य ऐप्लिकेशन के इस्तेमाल के लिए अपनी मेमोरी वापस पाने की ज़रूरत नहीं होती और इसकी ज़रूरत नहीं रह जाती.

Android की एक खास और बुनियादी सुविधा यह है कि ऐप्लिकेशन प्रोसेस का लाइफ़टाइम, ऐप्लिकेशन से सीधे तौर पर कंट्रोल नहीं होता. इसके बजाय, सिस्टम यह तय करता है कि ऐप्लिकेशन के कौनसे हिस्से चल रहे हैं, ये चीज़ें उपयोगकर्ता के लिए कितनी ज़रूरी हैं, और सिस्टम में कुल कितनी मेमोरी उपलब्ध है.

ऐप्लिकेशन डेवलपर के लिए यह समझना ज़रूरी है कि ऐप्लिकेशन के अलग-अलग कॉम्पोनेंट (खास तौर पर Activity, Service, और BroadcastReceiver), ऐप्लिकेशन की प्रोसेस के लाइफ़टाइम पर कैसे असर डालते हैं. इन कॉम्पोनेंट का सही तरीके से इस्तेमाल न करने पर, सिस्टम ऐप्लिकेशन की प्रोसेस को बंद कर सकता है. ऐसा तब हो सकता है, जब ऐप्लिकेशन कोई ज़रूरी काम कर रहा हो.

प्रोसेस लाइफ़साइकल की गड़बड़ी का एक सामान्य उदाहरण BroadcastReceiver है. यह अपने BroadcastReceiver.onReceive() तरीके में Intent मिलने पर थ्रेड शुरू करता है और फिर फ़ंक्शन से वापस आता है. इसके वापस आने के बाद, सिस्टम यह मान लेता है कि BroadcastReceiver अब चालू नहीं है. साथ ही, इसकी होस्टिंग प्रोसेस की अब ज़रूरत नहीं है. हालांकि, ऐसा तब तक होता है, जब तक इसमें ऐप्लिकेशन के अन्य कॉम्पोनेंट चालू न हों.

इसलिए, सिस्टम मेमोरी को वापस पाने के लिए, प्रोसेस को किसी भी समय बंद कर सकता है. ऐसा करने पर, प्रोसेस में चल रहे स्पॉन किए गए थ्रेड को बंद कर दिया जाता है. इस समस्या का समाधान आम तौर पर, BroadcastReceiver से JobService को शेड्यूल करना होता है, ताकि सिस्टम को पता चल सके कि प्रोसेस में ऐक्टिव काम हो रहा है.

मेमोरी कम होने पर, Android यह तय करता है कि किन प्रोसेस को बंद करना है. इसके लिए, वह हर प्रोसेस को अहमियत के हिसाब से एक क्रम में रखता है. यह क्रम, प्रोसेस में चल रहे कॉम्पोनेंट और उनकी स्थिति के आधार पर तय होता है. अहमियत के हिसाब से, ये प्रोसेस टाइप इस तरह हैं:

  1. फ़ोरग्राउंड प्रोसेस वह प्रोसेस होती है जो उपयोगकर्ता की मौजूदा गतिविधि के लिए ज़रूरी होती है. ऐप्लिकेशन के अलग-अलग कॉम्पोनेंट की वजह से, उसमें मौजूद प्रोसेस को अलग-अलग तरीकों से फ़ोरग्राउंड माना जा सकता है. किसी प्रोसेस को फ़ोरग्राउंड में तब माना जाता है, जब इनमें से कोई भी शर्त पूरी होती है:
    • यह स्क्रीन पर सबसे ऊपर Activity चला रहा है, जिसके साथ उपयोगकर्ता इंटरैक्ट कर रहा है. इसके onResume() तरीके को कॉल किया गया है.
    • इसमें एक BroadcastReceiver है, जो फ़िलहाल चल रहा है. इसका मतलब है कि इसका BroadcastReceiver.onReceive() तरीका लागू हो रहा है.
    • इसमें एक Service है, जो फ़िलहाल अपने किसी कॉलबैक (Service.onCreate(), Service.onStart() या Service.onDestroy()) में कोड को एक्ज़ीक्यूट कर रहा है.

    सिस्टम में ऐसी कुछ ही प्रोसेस होती हैं. इन्हें सिर्फ़ तब बंद किया जाता है, जब मेमोरी इतनी कम हो कि ये प्रोसेस भी जारी न रह सकें. आम तौर पर, ऐसा तब होता है, जब डिवाइस की मेमोरी पेजिंग की स्थिति में पहुंच जाती है. इसलिए, यूज़र इंटरफ़ेस को रिस्पॉन्सिव बनाए रखने के लिए, यह कार्रवाई ज़रूरी है.

  2. विज़िबल प्रोसेस वह प्रोसेस होती है जो उपयोगकर्ता को दिख रही होती है. इसलिए, इसे बंद करने से उपयोगकर्ता के अनुभव पर बुरा असर पड़ता है. किसी प्रोसेस को इन स्थितियों में विज़िबल माना जाता है:
    • यह एक Activity चला रहा है, जो उपयोगकर्ता को स्क्रीन पर दिखता है, लेकिन फ़ोरग्राउंड में नहीं. इसके लिए, onPause() तरीके को कॉल किया गया है. उदाहरण के लिए, ऐसा तब हो सकता है, जब फ़ोरग्राउंड Activity को डायलॉग के तौर पर दिखाया जाए, जिससे पिछली Activity को उसके पीछे देखा जा सके.
    • इसमें एक Service है, जो फ़ोरग्राउंड सेवा के तौर पर चल रहा है. यह Service.startForeground() के ज़रिए चलता है. यह सिस्टम से, सेवा को ऐसी चीज़ के तौर पर इस्तेमाल करने के लिए कहता है जिसके बारे में उपयोगकर्ता को पता हो या जो उसे दिख रही हो.
    • यह ऐसी सेवा को होस्ट कर रहा है जिसका इस्तेमाल सिस्टम किसी खास सुविधा के लिए कर रहा है. उपयोगकर्ता को इस सुविधा के बारे में पता होता है. जैसे, लाइव वॉलपेपर या इनपुट मेथड सर्विस.

    सिस्टम में चल रही इन प्रोसेस की संख्या, फ़ोरग्राउंड प्रोसेस की तुलना में कम सीमित होती है. हालांकि, फिर भी इन्हें कंट्रोल किया जाता है. इन प्रोसेस को बेहद अहम माना जाता है और इन्हें तब तक बंद नहीं किया जाता, जब तक कि फ़ोरग्राउंड में चल रही सभी प्रोसेस को चालू रखने के लिए ऐसा करना ज़रूरी न हो.

  3. सर्विस प्रोसेस वह प्रोसेस होती है जिसमें Service होता है. इसे startService() तरीके से शुरू किया जाता है. हालांकि, ये प्रोसेस उपयोगकर्ता को सीधे तौर पर नहीं दिखती हैं, लेकिन आम तौर पर ये ऐसे काम करती हैं जो उपयोगकर्ता के लिए ज़रूरी होते हैं. जैसे, बैकग्राउंड में नेटवर्क डेटा अपलोड या डाउनलोड करना. इसलिए, सिस्टम हमेशा ऐसी प्रोसेस को चालू रखता है. हालांकि, अगर फ़ोरग्राउंड और दिखने वाली सभी प्रोसेस को बनाए रखने के लिए ज़रूरत के मुताबिक मेमोरी नहीं है, तो सिस्टम ऐसी प्रोसेस को बंद कर देता है.

    लंबे समय से चल रही सेवाओं (जैसे, 30 मिनट या उससे ज़्यादा) को कम ज़रूरी माना जा सकता है, ताकि उनकी प्रोसेस को कैश मेमोरी में सेव की गई सूची में शामिल किया जा सके.

    जिन प्रोसेस को लंबे समय तक चलाने की ज़रूरत होती है उन्हें setForeground की मदद से बनाया जा सकता है. अगर यह एक ऐसी प्रोसेस है जो समय-समय पर होती है और इसे तय समय पर पूरा करना ज़रूरी है, तो इसे AlarmManager की मदद से शेड्यूल किया जा सकता है. ज़्यादा जानकारी के लिए, लंबे समय तक चलने वाले वर्कर्स के लिए सहायता लेख पढ़ें. इससे ऐसी स्थितियों से बचा जा सकता है जिनमें लंबे समय तक चलने वाली सेवाएं, ज़रूरत से ज़्यादा संसाधनों का इस्तेमाल करती हैं. उदाहरण के लिए, मेमोरी लीक होने से सिस्टम, उपयोगकर्ता को बेहतर अनुभव नहीं दे पाता.

  4. कैश मेमोरी में सेव की गई प्रोसेस वह होती है जिसकी फ़िलहाल ज़रूरत नहीं होती. इसलिए, जब मेमोरी जैसे संसाधनों की ज़रूरत कहीं और होती है, तो सिस्टम ज़रूरत के हिसाब से उसे बंद कर सकता है. सामान्य रूप से काम करने वाले सिस्टम में, रिसॉर्स मैनेजमेंट में सिर्फ़ ये प्रोसेस शामिल होती हैं.

    अच्छी तरह से काम करने वाले सिस्टम में, कैश मेमोरी में सेव की गई कई प्रोसेस हमेशा उपलब्ध होती हैं. इससे ऐप्लिकेशन के बीच आसानी से स्विच किया जा सकता है. साथ ही, कैश मेमोरी में सेव किए गए ऐप्लिकेशन को ज़रूरत के हिसाब से नियमित तौर पर बंद किया जाता है. सिर्फ़ बहुत गंभीर स्थितियों में, सिस्टम उस स्थिति में पहुंचता है जहां कैश मेमोरी में सेव की गई सभी प्रोसेस बंद हो जाती हैं और उसे सेवा प्रोसेस को बंद करना पड़ता है.

    कैश मेमोरी में सेव की गई प्रोसेस को सिस्टम कभी भी बंद कर सकता है. इसलिए, कैश मेमोरी में सेव होने के दौरान ऐप्लिकेशन को सभी काम बंद कर देने चाहिए. अगर ऐप्लिकेशन को उपयोगकर्ता के लिए ज़रूरी काम करना है, तो उसे ऊपर दिए गए एपीआई में से किसी एक का इस्तेमाल करना चाहिए, ताकि काम को चालू प्रोसेस की स्थिति से चलाया जा सके.

    कैश मेमोरी में सेव की गई प्रोसेस में अक्सर एक या उससे ज़्यादा Activity इंस्टेंस होते हैं, जो फ़िलहाल उपयोगकर्ता को नहीं दिखते. ऐसा इसलिए होता है, क्योंकि उनके onStop() तरीके को कॉल किया गया है और वह वापस आ गया है. अगर सिस्टम ऐसी प्रोसेस को बंद कर देता है, तो ऐप्लिकेशन को अपनी Activity लाइफ़साइकल को सही तरीके से लागू करना चाहिए. इससे, उपयोगकर्ता के उस ऐप्लिकेशन पर वापस आने पर, उसके अनुभव पर कोई असर नहीं पड़ता. जब उससे जुड़ी गतिविधि को नई प्रोसेस में फिर से बनाया जाता है, तो वह पहले से सेव की गई स्थिति को वापस ला सकता है. ध्यान रखें कि अगर सिस्टम किसी प्रोसेस को बंद कर देता है, तो इस बात की कोई गारंटी नहीं है कि onDestroy() को कॉल किया जाएगा. ज़्यादा जानकारी के लिए, Activity देखें.

    Android 13 से, किसी ऐप्लिकेशन प्रोसेस को एक्ज़ीक्यूशन के लिए सीमित समय मिल सकता है या हो सकता है कि उसे एक्ज़ीक्यूशन के लिए समय ही न मिले. ऐसा तब तक होगा, जब तक वह ऊपर बताई गई किसी ऐक्टिव लाइफ़साइकल स्टेट में नहीं आ जाती.

    कैश मेमोरी में सेव की गई प्रोसेस को एक सूची में रखा जाता है. इस सूची के लिए, क्रम से लगाने की सटीक नीति, प्लैटफ़ॉर्म को लागू करने की जानकारी है. आम तौर पर, यह अन्य तरह की प्रोसेस से पहले, ज़्यादा काम की प्रोसेस को बनाए रखने की कोशिश करता है. जैसे, उपयोगकर्ता के होम ऐप्लिकेशन को होस्ट करने वाली प्रोसेस या उपयोगकर्ता की देखी गई पिछली गतिविधि. प्रोसेस को बंद करने के लिए अन्य नीतियां भी लागू की जा सकती हैं. जैसे, प्रोसेस की संख्या पर सख्त सीमाएं सेट करना या किसी प्रोसेस को लगातार कैश मेमोरी में सेव रखने की समयसीमा तय करना.

किसी प्रोसेस को कैटगरी में बांटने के लिए, सिस्टम अपना फ़ैसला उस प्रोसेस में फ़िलहाल चालू सभी कॉम्पोनेंट में से सबसे अहम लेवल के आधार पर लेता है. Activity, Service, और BroadcastReceiver के दस्तावेज़ देखें. इनमें इस बारे में ज़्यादा जानकारी दी गई है कि इनमें से हर कॉम्पोनेंट, किसी प्रोसेस और ऐप्लिकेशन के पूरे लाइफ़साइकल में कैसे योगदान देता है.

किसी प्रोसेस की प्राथमिकता को, उस पर निर्भर अन्य प्रोसेस के आधार पर भी बढ़ाया जा सकता है. उदाहरण के लिए, अगर प्रोसेस A को Context.BIND_AUTO_CREATE फ़्लैग के साथ Service से जोड़ा गया है या प्रोसेस B में ContentProvider का इस्तेमाल किया जा रहा है, तो प्रोसेस B की कैटगरी हमेशा प्रोसेस A की कैटगरी जितनी ही अहम होती है.