Bagaimana pengurusan memori berfungsi dalam Android dan bagaimana anda mengelakkan kebocoran?

Question

Accepted Answer

Aplikasi Android berjalan dengan **memori terhad** dan tertakluk kepada sistem membunuh aplikasi di bawah tekanan memori. Memahami pengurusan memori — dan terutamanya **mengelakkan kebocoran memori** (masalah Android yang biasa dan serius) — adalah penting untuk aplikasi yang stabil dan berprestasi.

## Asas memori 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
```

## Kebocoran memori — masalah biasa

```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!)
```

## Mengelakkan kebocoran

```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
```

## Mengapa ia penting

Memahami pengurusan memori Android dan mengelakkan kebocoran adalah pengetahuan peringkat senior yang penting kerana **kebocoran memori ialah masalah Android yang biasa dan serius** yang merosotkan prestasi dan menyebabkan kerosakan, dan persekitaran Android yang berkurang memori dan membunuh aplikasi menjadikan kecekapan memori penting, jadi ia berharga untuk membina aplikasi yang stabil.

Aplikasi Android berjalan dengan **memori terhad** dan sistem boleh membunuh aplikasi di bawah tekanan memori, manakala garbage collection menuntut semula objek yang tidak boleh dicapai tetapi tidak boleh membebaskan objek yang kekal dirujuk (kebocoran) — menjadikan pengurusan memori penting, terutamanya memandangkan banyak peranti Android berkurang memori. **Kebocoran memori ialah masalah Android yang amat biasa dan berkesan**: objek yang tidak lagi diperlukan tetapi masih dirujuk tidak boleh dikutip-sampah, dan **kebocoran Android klasik melibatkan memegang rujukan Activity/Context melepasi kitar hayatnya** (melalui static fields, singletons, listener tahan lama, inner classes, handlers, atau coroutines tidak dibatal yang menangkap Activity) — yang amat buruk kerana Activity yang bocor menyeret keseluruhan pokok view-nya, satu kebocoran memori yang besar.

Memahami corak kebocoran ini adalah penting kerana ia merupakan punca kerap dan nyata masalah memori dan kerosakan.

Memahami **cara mengelakkan kebocoran** — tidak memegang Activity/Context dalam objek static atau tahan lama (menggunakan applicationContext di mana sesuai), menyahdaftar listener dan membatalkan coroutines (lifecycle scopes membatal secara automatik), menggunakan **komponen sedar kitar hayat** (ViewModel, lifecycleScope, LiveData yang membersih secara automatik), berhati-hati dengan inner classes/handlers, dan **mengesan kebocoran dengan LeakCanary** serta pemprofilan — ialah pengetahuan praktikal penting untuk mencegahnya.

Memandangkan kebocoran memori ialah masalah Android yang biasa dan serius (terutamanya kebocoran Activity/Context) dan persekitaran memori terhad Android menjadikan kecekapan penting, dan memandangkan memahami pengurusan memori serta corak untuk mengelakkan kebocoran (komponen sedar kitar hayat, pembersihan yang betul, alat pengesanan) adalah perlu untuk aplikasi yang stabil dan berprestasi, memahami pengurusan memori Android dan mengelakkan kebocoran adalah pengetahuan peringkat senior yang penting — menangani salah satu masalah Android yang paling biasa dan berkesan, mencerminkan kepakaran khusus platform yang diperlukan untuk membina aplikasi yang stabil dan kedalaman yang dijangka untuk peranan Android senior.