Android Academy · Les

Prestaties meten

Profilers, traces en benchmarks.

Les 1 van 413 stappen

Prestaties meten is een gratis Android Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Android Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Android Academy bevat in totaal 4 lessen.

Meten voordat je optimaliseert

De gouden regel voor prestatieverbeteringen: meet eerst en gok nooit. Je menselijke intuïtie over wat traag is, zit er bijna altijd naast.

In deze les leer je welke tools Android biedt om prestaties te zien: de profilers, systeemtraceringen en microbenchmarks. Zodra je kunt meten, wordt elke optimalisatie een datagestuurde beslissing in plaats van een vermoeden.

Profilers tonen CPU, geheugen en energie in realtime.
Systeemtraceringen laten precies zien waar de tijd van elk frame naartoe gaat.
Benchmarks leveren herhaalbare getallen die je tussen builds kunt vergelijken.

Het budget van 16 ms per frame

Op een scherm van 60 Hz tekent het systeem elke 16,67 ms een nieuw frame. Als je app binnen dat tijdvenster geen frame kan voorbereiden, wordt het frame overgeslagen en ervaren gebruikers haperingen (stotteren). Op apparaten van 120 Hz krimpt het budget tot ongeveer 8 ms.

Werk aan prestaties draait er in feite om binnen dit budget te blijven. De opmerking hieronder laat de berekening zien die je voortdurend in gedachten houdt.

// Frame budget math
// 60 Hz  -> 1000ms / 60  = 16.67ms per frame
// 90 Hz  -> 1000ms / 90  = 11.11ms per frame
// 120 Hz -> 1000ms / 120 =  8.33ms per frame
//
// Exceed the budget on the UI thread = a dropped frame = visible jank.
fun frameBudgetMs(refreshHz: Int): Double = 1000.0 / refreshHz

fun main() {
    println("60Hz  -> %.2f ms".format(frameBudgetMs(60)))
    println("120Hz -> %.2f ms".format(frameBudgetMs(120)))
}

Android Studio Profiler

De Android Studio Profiler (View > Tool Windows > Profiler) maakt verbinding met een actieve app en toont live tijdlijnen voor CPU, geheugen, energie en netwerk.

CPU: leg methode- en systeemtraceringen vast om drukke codepaden te vinden.
Geheugen: houd toewijzingen in de gaten en leg heap-dumps vast om lekken te vinden.
Energie: spoor wakelocks en overmatige taken op die de batterij leegtrekken.

Profileer altijd een release-achtige build op een echt apparaat. Debug-builds en emulators geven misleidende getallen, omdat optimalisaties zijn uitgeschakeld.

Macrobenchmark voor realistische scenario's

De bibliotheek Jetpack Macrobenchmark meet volledige gebruikersreizen (opstarten, scrollen, navigatie) op een echt apparaat en rapporteert stabiele meetwaarden, zoals frametiming en opstarttijd.

Je schrijft een test die je app start en een gebruikersstroom uitvoert; de bibliotheek voert die vele keren uit en geeft je de mediaan en waarden van het 99e percentiel.

@RunWith(AndroidJUnit4::class)
class StartupBenchmark {
    @get:Rule val rule = MacrobenchmarkRule()

    @Test
    fun coldStartup() = rule.measureRepeated(
        packageName = "com.example.app",
        metrics = listOf(StartupTimingMetric()),
        iterations = 5,
        startupMode = StartupMode.COLD
    ) {
        pressHome()
        startActivityAndWait()
    }
}

Microbenchmark voor drukke code

Als je wilt weten hoe snel één functie is, gebruik je de bibliotheek Microbenchmark. Deze voert je code uit in een krappe lus, warmt de JIT op en rapporteert nanoseconden per bewerking, waarbij ruis wordt verwijderd.

Gebruik dit voor parsers, serializers, sorteringen of elke CPU-intensieve helper die je vaak aanroept.

@RunWith(AndroidJUnit4::class)
class JsonParseBenchmark {
    @get:Rule val benchmarkRule = BenchmarkRule()

    @Test
    fun parseLargePayload() {
        val raw = loadSampleJson()
        benchmarkRule.measureRepeated {
            val parsed = parseUsers(raw) // code under test
            // assertEquals avoids the compiler dropping the result
            assertTrue(parsed.isNotEmpty())
        }
    }
}

Systeemtracering met Perfetto

Systeemtracering legt vast wat elke thread en het systeem hebben gedaan, frame voor frame. De CPU-profiler van Android Studio kan zo'n tracering opnemen, en je kunt er ook een vastleggen met adb en die openen in Perfetto (ui.perfetto.dev).

Een tracering toont de gevreesde rode frames, het werk op de hoofdthread en de tijd die in de GPU wordt doorgebracht. Dit is het beste hulpmiddel om haperingen vast te stellen.

# Record a 5-second system trace from the command line
adb shell perfetto -o /data/misc/perfetto-traces/trace.perfetto-trace \
  -t 5s sched freq idle am wm gfx view

# Pull it to your machine, then open in https://ui.perfetto.dev
adb pull /data/misc/perfetto-traces/trace.perfetto-trace

Aangepaste traceringsecties

Standaard tonen traceringen werk van het framework. Om je eigen code te labelen, wikkel je die in een benoemde traceringsectie. Deze namen verschijnen vervolgens als gelabelde blokken in Perfetto, waardoor je hotspots gemakkelijk kunt vinden.

Gebruik de API androidx.tracing, zodat secties zowel in debugtraceringen als in benchmarktraceringen verschijnen.

import androidx.tracing.trace

fun loadDashboard(repo: Repo): Dashboard {
    return trace("loadDashboard") {
        val user = trace("fetchUser") { repo.user() }
        val feed = trace("fetchFeed") { repo.feed() }
        Dashboard(user, feed)
    }
}
// In Perfetto you will now see named slices:
// loadDashboard > fetchUser, fetchFeed

Overgeslagen frames tijdens runtime bijhouden

Je hebt niet altijd een profiler gekoppeld. JankStats is een Jetpack-bibliotheek die haperende frames vanuit je actieve app rapporteert, zodat je ze kunt loggen of totalen naar analysetools kunt sturen.

De bibliotheek koppelt zich aan het venster en roept je terug telkens wanneer een frame het budget overschrijdt.

val jankStats = JankStats.createAndTrack(window) { frameData ->
    if (frameData.isJank) {
        Log.w("Jank", "Janky frame: ${frameData.frameDurationUiNanos} ns")
        analytics.logJank(frameData.frameDurationUiNanos)
    }
}

// Pause/resume with your screen lifecycle
override fun onResume() { super.onResume(); jankStats.isTrackingEnabled = true }
override fun onPause() { super.onPause(); jankStats.isTrackingEnabled = false }

De getallen lezen: percentielen

Een enkel gemiddelde verbergt problemen. Als je gemiddelde frame 10 ms duurt, maar het 99e percentiel 40 ms is, hapert 1% van de frames en merken gebruikers dat. Kijk altijd naar P50, P90, P99, niet alleen naar het gemiddelde.

Benchmarks rapporteren deze waarden voor je. De helper hieronder laat het idee zien aan de hand van onbewerkte framemonsters.

fun percentile(samplesMs: List<Double>, p: Int): Double {
    val sorted = samplesMs.sorted()
    val index = ((p / 100.0) * (sorted.size - 1)).toInt()
    return sorted[index]
}

fun main() {
    val frames = listOf(8.0, 9.0, 10.0, 9.5, 11.0, 40.0, 9.0, 10.5)
    println("P50 = %.1f ms".format(percentile(frames, 50)))
    println("P99 = %.1f ms".format(percentile(frames, 99)))
}

Een herhaalbare meetworkflow

Betrouwbare getallen komen voort uit een gedisciplineerd proces. Volg deze checklist elke keer:

Gebruik een release-build / niet-debugbare build (R8 ingeschakeld).
Voer de meting uit op een fysiek apparaat dat is aangesloten en een stabiele thermische toestand heeft.
Herhaal het scenario meerdere keren en rapporteer de mediaan.
Verander telkens één ding en meet opnieuw.
Vergelijk met een opgeslagen referentiewaarde, zodat je verbetering kunt aantonen.

Als je dit overslaat, jaag je ruis na in plaats van echte problemen op te lossen.

Waar de tijd echt naartoe gaat

De meeste haperingen in Android komen door een kleine groep oorzaken. Als je die kent, weet je waarop je hulpmiddelen moet richten:

Werk op de hoofdthread: schijf, netwerk of JSON op de UI-thread.
Te veel recompositie: Compose tekent veel te veel opnieuw.
Toewijzingsdrukte: pauzes door garbagecollection.
Lay-outpasses: diep geneste of herhaaldelijk gemeten lay-outs.

De volgende lessen in deze cursus behandelen recompositie, geheugenlekken en opstarten rechtstreeks. Meten vertelt je welke je als eerste moet oplossen.

Korte controle

Je wilt op een echt apparaat een stabiele, herhaalbare meting van hoelang de koude opstart van je app duurt, verspreid over meerdere uitvoeringen. Welk hulpmiddel past hier het best bij?

Beantwoord dit in de interactieve les

Samenvatting: je kunt nu meten

Je hebt geleerd prestaties zichtbaar te maken voordat je iets verandert:

Het framebudget van 16 ms bepaalt het verschil tussen vloeiende beelden en haperingen.
De Android Studio Profiler toont live CPU-, geheugen- en energiegegevens.
Macro- en microbenchmarks leveren herhaalbare getallen.
Perfetto-traceringen en aangepaste trace()-secties laten zien waar de tijd naartoe gaat.
JankStats rapporteert haperingen vanuit de actieve app.
Lees P50/P90/P99, profileer release-builds op echte apparaten en verander telkens één ding.

Vervolgens passen we dit toe op een van de grootste oorzaken van haperingen in Compose: recompositie.

Gratis beginnen

Leer Kotlin met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 36
Lessen: 152

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Prestaties meten” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Android Academy, waaronder “Prestaties meten”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Android Academy bevat in totaal 4 lessen.

Wat leer ik in “Prestaties meten”?

Profilers, traces en benchmarks. Je oefent met Android Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Android Academy te beginnen?

Ervaring vooraf is niet nodig. Android Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Prestaties meten”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Android Academy?

Ja. Elke les over Android Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Android Academy