Android-ல் மெமோரி மேலாண்மை எவ்வாறு செயல்படுகிறது மற்றும் நீங்கள் எவ்வாறு leaks-ஐ தவிர்க்கலாம்?

Question

Accepted Answer

Android அப்ளிகேஷன்கள் **மட்டுப்படுத்தப்பட்ட மெமோரி**யுடன் இயங்குகின்றன மற்றும் மெமோரி அழுத்தத்தின் கீழ் கணினி அப்ளிகேஷன்களைக் கொல்லலாம். மெமோரி மேலாண்மையைப் புரிந்துகொள்வது — மற்றும் குறிப்பாக **மெமோரி leaks-ஐ தவிர்ப்பது** (ஒரு பொதுவான, கடுமையான Android சிக்கல்) — நிலையான, செயல்திறன் உள்ள அப்ளிகேஷன்களுக்கு முக்கியமாகும்.

## Android மெமோரி அடிப்படைகள்

```text
→ Apps have a LIMITED heap; the system can KILL background apps to reclaim memory
→ Garbage collection reclaims unreachable objects — but GC pauses can cause jank, and
  objects that STAY reachable (leaks) are never collected
→ Low-memory devices are common (Android's range) → memory efficiency matters
```

## மெமோரி leaks — பொதுவான சிக்கல்

```text
A LEAK = an object that's no longer needed but is still REFERENCED (so GC can't free it).
Classic Android leaks:
  ✗ Holding an ACTIVITY/Context reference beyond its lifecycle:
    - a static field or singleton holding an Activity/Context
    - a long-lived listener/callback capturing an Activity
    - an inner class / non-cancelled coroutine / handler holding the Activity
  → the Activity can't be GC'd after it's destroyed → its whole view tree leaks (big!)
```

## Leaks-ஐ தவிர்ப்பது

```text
✓ Don't hold Activity/Context in static fields or long-lived objects (use applicationContext
  where a long-lived context is needed)
✓ UNREGISTER listeners/observers; CANCEL coroutines (lifecycle scopes auto-cancel)
✓ Use LIFECYCLE-AWARE components (ViewModel, lifecycleScope, LiveData) — they clean up
✓ Be careful with inner classes/handlers (use weak references or static + WeakReference)
✓ DETECT with LeakCanary (flags leaks in development); profile memory in Android Studio
```

## இது ஏன் முக்கியமானது

Android மெமோரி மேலாண்மை மற்றும் leaks-ஐ தவிர்ப்பதைப் புரிந்துகொள்வது முக்கியமான மூத்த-நிலை அறிவாகும், ஏனெனில் **மெமோரி leaks ஒரு பொதுவான, கடுமையான Android சிக்கல்** ஆகும் இது செயல்திறனை குறைக்கிறது மற்றும் செயலிழப்பை ஏற்படுத்துகிறது, மேலும் Android-இன் மட்டுப்படுத்தப்பட்ட-மெமோரி, அப்ளிகேஷன்-கொல்லும் சூழல் மெமோரி திறனை முக்கியமாக்குகிறது, எனவே இது நிலையான அப்ளிகேஷன்கள் உருவாக்குவதற்கு மதிப்புள்ளதாகும்.

Android அப்ளிகேஷன்கள் **மட்டுப்படுத்தப்பட்ட மெமோரி**யுடன் இயங்குகின்றன மற்றும் மெமோரி அழுத்தத்தின் கீழ் கணினி அப்ளிகேஷன்களைக் கொல்லலாம், garbage collection மீட்டெடுக்க முடியாத பொருட்களை மீளப்பெறுகிறது ஆனால் குறிப்புகள் இருக்கும் பொருட்களை விடுவிக்க முடியாது (leaks) — மெமோரி மேலாண்மையை முக்கியமாக்குகிறது, குறிப்பாக Android-இன் பல குறைந்த-மெமோரி சாதனங்கள் கொடுக்கப்பட்டுள்ளன. **மெமோரி leaks குறிப்பாக ஒரு பொதுவான மற்றும் தாக்க முடிய Android சிக்கல்**: இனி தேவைப்படாத ஆனால் இன்னும் குறிப்பு செய்யப்பட்ட பொருள் garbage-சேகரிக்க முடியாது, மற்றும் **கிளாசிக் Android leaks Activity/Context குறிப்புகளை அவற்றின் lifecycle-க்கு அப்பால் வைத்திருப்பது சம்பந்தப்படுகிறது** (static புலங்கள் மூலம், singletons, நீண்ட-நிலை listeners, உள் வகுப்புகள், handlers, அல்லது மாற்றப்படாத coroutines ஒரு Activity ஐ கைப்பற்றும்) — இது குறிப்பாக மோசமாகும், ஏனெனில் leaked Activity அதன் முழு view tree-ஐ இழுத்துச் செல்கிறது, ஒரு பெரிய மெமோரி leak.

இந்த leak வடிவங்களைப் புரிந்துகொள்வது முக்கியமாகும், ஏனெனில் அவை மெமோரி சிக்கல்கள் மற்றும் செயலிழப்புகளின் அடிக்கடி, உண்மையான மூலங்களாகும்.

**Leaks-ஐ தவிர்ப்பது** — Activity/Context-ஐ static அல்லது நீண்ட-நிலை பொருட்களில் வைத்திருப்பது (தகுந்தமான இடத்தில் applicationContext பயன்படுத்தி), listeners-ஐ நிலைநிறுத்தி மற்றும் coroutines-ஐ மாற்றுவது (lifecycle scopes தானாக-மாற்றுகிறது), **lifecycle-aware components** (ViewModel, lifecycleScope, LiveData ஆ தானாக சரிசெய்யும்) பயன்படுத்துவது, உள் வகுப்புகள்/handlers-ஐ கவனமாக பயன்படுத்துவது, மற்றும் **LeakCanary-உடன் leaks-ஐ கண்டறிவது** மற்றும் profiling — அவற்றைத் தடுப்பதற்கான அத்யாவசிய நடைமுறைத் தெரிவாகும்.

மெமோரி leaks ஒரு பொதுவான, கடுமையான Android சிக்கல் என்பதால் (குறிப்பாக Activity/Context leaks) மற்றும் Android-இன் மட்டுப்படுத்தப்பட்ட-மெமோரி சூழல் திறனை முக்கியமாக்குகிறது, மற்றும் மெமோரி மேலாண்மை மற்றும் leaks-ஐ தவிர்க்க வேண்டிய வடிவங்களைப் புரிந்துகொள்வது (lifecycle-aware components, சரியான cleanup, கண்டறிதல் கருவிகள்) நிலையான, செயல்திறன் உள்ள அப்ளிகேஷன்களுக்கு அவசியமாகும், Android மெமோரி மேலாண்மை மற்றும் leak தவிர்ப்புணர்வு புரிந்துகொள்வது முக்கியமான மூத்த-நிலை அறிவாகும் — மிகவும் பொதுவான, தாக்க முடிய Android சிக்கலில் ஒன்றிற்குத் தீர்வு கொடுக்கிறது, நிலையான அப்ளிகேஷன்கள் உருவாக்குவதற்கு தேவைப்படும் தளம்-குறிப்பிட்ட দক்ষதையை பிரதিபலிக்கிறது மற்றும் மூத்த Android பாத்திரங்களுக்கு எதிர்பார்க்கப்படும் ஆழத்தை பிரதிபலிக்கிறது.