Memóriát eszik és duzzad — mi ez, okok és hogyan kerülhető el

Mi a memóriaszivárgás és az alkalmazás duzzadása?

Memóriaszivárgás (memory leak) — olyan helyzet, amikor egy objektum, amelyre az alkalmazásnak már nincs szüksége, továbbra is a heap-ben marad, mert aktív hivatkozás van rá a gyökérkészletből (GC Root). A szemétgyűjtő az ilyen objektumot élőnek tekinti és nem törli.

Memória duzzadása (memory bloat) — tágabb probléma, amikor az alkalmazás több memóriát fogyaszt, mint amennyi a jelenlegi feladatok elvégzéséhez szükséges. Okok: túlzott gyorsítótárazás, objektumok duplikálása, nem optimális adatszerkezetek és a heap fragmentálódása.

Androidban minden alkalmazás korlátozott heap-et kap (általában 64-512 MB-ot, az eszköztől és az OS verziójától függően). iOS-ben a korlátozás kevésbé szigorú, de a rendszer memóriafigyelmeztetést küld a határ megközelítésekor.

A Facebook Engineering Blog szerint a memóriaszivárgások a mobil alkalmazásokban előforduló crash jelentések ~15%-ának okai. Androidban ehhez hozzáadódnak az ANR-ek a gyakori GC szünetek miatt memóriahiány esetén.

Tipikus memóriaszivárgási minták Androidban és iOS-ben

Statikus hivatkozás Activity-re — az Android szivárgások klasszikusa. Ha egy statikus mező vagy singleton hivatkozást tárol egy Activity-re, azt a GC még finish() után sem gyűjti be, amíg a singleton él. Az Activity egy nehéz objektum, amely View hierarchiát, erőforrásokat és Context-et tartalmaz.

object LeakHolder {
    var activityRef: Activity ?= null // szivárgás: statikus hivatkozás Activity-re
}

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle ?= null) {
        super.onCreate(savedInstanceState)
        LeakHolder.activityRef = this // ❌ A MainActivity-t soha nem gyűjti be a GC
    }
}

Anonim osztályok és lambdák — implicit módon hivatkozást tartanak a külső osztályra. Ha egy Runnable vagy Callback egy külső szolgáltatásnak kerül átadásra, és az Activity megsemmisül, az anonim osztály objektuma még mindig a sorban lóg, és nem engedi, hogy az Activity-t a szemétgyűjtő begyűjtse.

• Handler késleltetéssel — ha az Activity megsemmisült, de a Handler.postDelayed még nem futott le, az Activity szivárog
• Thread és AsyncTask — képernyőforgatáskor az Activity újra létrejön, de a régi Thread továbbra is tartja a hivatkozást a régi Activity-re
• Retrofit/Callback — egy anonim Callback hivatkozást tart a presenter-re vagy fragment-re
• Megfigyelők (Observers) — LiveData vagy RxJava feliratkozások törlés nélkül onDestroy-kor

iOS-ben a fő probléma a retain ciklus: két objektum erős hivatkozásokat tart egymásra, és az ARC egyiknek sem tudja nullázni a hivatkozás számlálóját. Tipikus eset: egy closure, amely erősen capture-öli a self-et, és a self, amely hivatkozást tart a closure-re.

Hogyan észleljük a memóriaszivárgásokat?

LeakCanary — a Square könyvtára automatikus szivárgásészleléshez Androidban. Az Activity vagy Fragment megsemmisülése után ellenőrzi, hogy az objektumot begyűjtötte-e a GC. Ha nem — heap dump-ot készít és megjeleníti a szivárgás nyomvonalát.

// LeakCanary 2.x — auto-integráció Application-en keresztül
class ExampleApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        // A LeakCanary automatikusan települ debug build-ben
        // ContentProvider-en keresztül — nulla kód beállítás
    }
}

// Kényszerített ellenőrzési hívás
AppWatcher.objectWatcher.watch(watchedObject, "leak description")

Android Studio Profiler — a beépített eszköz valós idejű memóriafigyeléshez. Lehetővé teszi heap dump rögzítését, gyanús objektumok (Retained Size > 1 MB) megtalálását és a GC root útvonal követését minden objektumhoz.

iOS-hez használja a Xcode Memory Graph Debugger-t. Ez vizualizálja az objektumok gráfját a memóriában, megjeleníti a retain ciklusokat, és lehetővé teszi a körkörös hivatkozások azonnali észlelését. Elérhető továbbá az Instruments > Allocations hosszú távú figyeléshez.

Szivárgásmegelőzési stratégiák

WeakReference — az alapvető mechanizmus azokhoz a hivatkozásokhoz, amelyek nem akadályozhatják a szemétgyűjtést. Ha a GC úgy dönt, hogy törli az objektumot, a WeakReference null-t ad vissza. Callback-ekhez, listener-ekhez és UI komponensekre mutató hivatkozásokhoz használják háttérszálakból.

Lifecycle-aware komponensek — az Android Jetpack-ben (Lifecycle, LiveData, Flow, coroutines) megvalósított architekturális megközelítés. A feliratkozások automatikusan törlődnek onDestroy-kor, ami kiküszöböli a szivárgások fő osztályát.

class MyViewModel : ViewModel() {
    private val _data = MutableLiveData<List<User>>()
    val data: LiveData<List<User>> get() = _data

    fun loadData() {
        viewModelScope.launch {
            val result = repository.fetchData()
            _data.postValue(result)
            // a korutin automatikusan törlődik onCleared()-kor
        }
    }
}

viewModelScope és lifecycleScope — beépített CoroutineScope-ok Androidban, amelyek a megfelelő életciklus-eseménykor törlődnek. Ez kiküszöböli a korutinokon keresztüli szivárgásokat — a legáltalánosabb forgatókönyvet a modern Android fejlesztésben.

• Ne használjon statikus hivatkozásokat Context, Activity, View vagy Fragment objektumokra
• Törölje az összes RxJava feliratkozást a disposeBag / CompositeDisposable segítségével onDestroy-kor
• Használjon [weak self] / [unowned self] iOS closure-ökben a retain ciklusok megelőzéséhez
• Ellenőrizze a Bitmap-eket és nagy objektumokat — újra kell hasznosítani vagy nullázni kell őket

Memóriaprofilozó eszközök

Memory Profiler in Android Studio — a fő eszköz a heap figyeléséhez. Élő foglalásokat, heap pillanatképeket, objektumok számát típusonként jeleníti meg. Lehetővé teszi dump rögzítését és elemzését a MAT (Memory Analyzer Tool) segítségével a gyanús objektumok megtalálásához.

Eclipse MAT — asztali heap dump elemző. Az Android Studio-ból betöltött HPROF fájl után a MAT dominátor fát épít, megjeleníti az egyes objektumok retain méretét, és automatikus elemzést kínál a gyanús szivárgásokról a Leak Suspects Report segítségével.

Xcode Memory Graph — vizuális debugger retain ciklusokhoz. A Memory Graph Debugger gombra kattintva az Xcode leállítja az alkalmazást, felépíti az objektumok teljes gráfját a memóriában, és pirossal kiemeli a retain ciklusokat.

A Google I/O 2023 szerint azok az alkalmazások, amelyek debug build-ben használják a LeakCanary-t, 30-50%-kal csökkentik a memóriával kapcsolatos crash-ek számát a bevezetés utáni első 2 hónapban. Javasolt a LeakCanary hozzáadása a projekt onboarding fázisában.