Android Academy · leksjon

Måle ytelse

Profileringsverktøy, spor og ytelsesmålinger.

Leksjon 1 av 413 trinn

Måle ytelse er en gratis leksjon i Android Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Android Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Android Academy inneholder totalt 4 leksjoner.

Mål før du optimaliserer

Den gylne regelen for ytelsesarbeid er: mål først, gjett aldri. Menneskelig intuisjon om hva som er tregt, er nesten alltid feil.

I denne leksjonen lærer du om verktøyene Android gir deg for å se ytelsen: profileringsverktøy, systemspor og mikroytelsestester. Når du kan måle, blir all optimalisering en datadrevet beslutning i stedet for en antakelse.

Profileringsverktøy viser CPU, minne og energiforbruk i sanntid.
Systemspor viser nøyaktig hvor tiden for hver ramme går.
Ytelsestester gir gjentakbare tall som du kan sammenligne mellom bygg.

Rammebudsjettet på 16 ms

På en skjerm med 60 Hz tegner systemet et nytt bilde hver 16,67 ms. Hvis appen ikke klarer å klargjøre et bilde innenfor dette tidsrommet, blir bildet droppet, og brukerne opplever hakking (stotring). På enheter med 120 Hz krymper budsjettet til omtrent 8 ms.

Ytelsesarbeid handler egentlig om å holde seg innenfor dette budsjettet. Kommentaren nedenfor viser matematikken De må ha i bakhodet.

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

Android Studio Profiler (View > Tool Windows > Profiler) kobler seg til en app som kjører, og viser tidslinjer i sanntid for CPU, minne, energi og nettverk.

CPU: Ta opp metode- og systemspor for å finne kodebaner som bruker mye tid.
Minne: Følg med på allokeringer og ta heap-dumper for å finne lekkasjer.
Energi: Finn wakelocks og unødvendige jobber som tømmer batteriet.

Profiler alltid et release-lignende bygg på en fysisk enhet. Debug-bygg og emulatorer gir misvisende tall fordi optimaliseringer er deaktivert.

Makrobenchmarking av virkelige scenarier

Biblioteket Jetpack Macrobenchmark måler komplette brukerforløp (oppstart, rulling, navigasjon) på en fysisk enhet og rapporterer stabile måltall, for eksempel bildetid og oppstartstid.

De skriver en test som starter appen og gjennomfører et forløp. Biblioteket kjører det mange ganger og gir Dem medianen og tallene for 99-persentilen.

@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()
    }
}

Mikrobenchmarking av kode som bruker mye tid

Når De trenger å vite hvor rask én enkelt funksjon er, bruker De biblioteket Microbenchmark. Det kjører koden i en tett løkke, varmer opp JIT og rapporterer nanosekunder per operasjon, med støyen fjernet.

Bruk det for parsere, serialisering, sortering eller andre CPU-bundne hjelpefunksjoner som kalles ofte.

@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())
        }
    }
}

Systemsporing med Perfetto

Systemsporing registrerer hva hver tråd og systemet gjorde, bilde for bilde. CPU-profileren i Android Studio kan ta opp et slikt spor, og De kan også ta opp med adb og åpne det i Perfetto (ui.perfetto.dev).

Et spor viser de fryktede røde bildene, arbeidet på hovedtråden og tiden som brukes av GPU-en. Det er det beste enkeltverktøyet for å diagnostisere hakking.

# 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

Egendefinerte sporingsseksjoner

Som standard viser spor rammeverkets arbeid. Hvis De vil merke Deres egen kode, pakker De den inn i en navngitt sporingsseksjon. Disse navnene vises deretter som merkede blokker i Perfetto, slik at det er lett å oppdage hvor flaskehalsene er.

Bruk API-et androidx.tracing slik at seksjonene vises i både debug- og benchmarkspor.

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

Sporing av droppede bilder under kjøring

De har ikke alltid en profiler koblet til. JankStats er et Jetpack-bibliotek som rapporterer hakkende bilder fra appen mens den kjører, slik at De kan logge dem eller sende aggregater til analyseverktøy.

Det kobler seg til vinduet og varsler Dem hver gang et bilde overskrider budsjettet.

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 }

Slik leser De tallene: Persentiler

Et enkelt gjennomsnitt skjuler problemene. Hvis gjennomsnittlig bildetid er 10 ms, men 99-persentilen er 40 ms, er 1 % av bildene hakkende, og brukerne merker det. Se alltid på P50, P90, P99, ikke bare gjennomsnittet.

Benchmarkene rapporterer disse tallene for Dem. Hjelpefunksjonen nedenfor viser ideen med rå bildemålinger.

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)))
}

En måleprosess som kan gjentas

Pålitelige tall kommer fra en disiplinert prosess. Følg denne sjekklisten hver gang:

Bruk et release- / ikke-debuggbart bygg (R8 aktivert).
Kjør på en fysisk enhet som er koblet til strøm, og med en stabil termisk tilstand.
Gjenta scenariet flere ganger og rapporter medianen.
Endre én ting om gangen og mål på nytt.
Sammenlign med en lagret baseline, slik at De kan dokumentere forbedringen.

Hvis De hopper over dette, kommer De til å jage støy i stedet for å løse reelle problemer.

Hvor tiden faktisk går

Det meste av hakkingen i Android skyldes et lite sett med årsaker. Når De kjenner dem, vet De hvor verktøyene skal settes inn:

Arbeid på hovedtråden: disk, nettverk eller JSON på UI-tråden.
For mange rekombineringer: Compose tegner opp altfor mye på nytt.
Allokeringspress: pauser for søppelinnsamling.
Layout-gjennomganger: dypt nestede eller gjentatte målinger av layouter.

De neste leksjonene i kurset tar direkte for seg rekombinering, minnelekkasjer og oppstart. Det er målingene som forteller Dem hva De bør fikse først.

Rask sjekk

De ønsker en stabil og gjentakbar måling av hvor lang tid appens kalde oppstart tar på en fysisk enhet over flere kjøringer. Hvilket verktøy passer best?

Besvar den i den interaktive leksjonen

Oppsummering: Nå kan De måle

De har lært å gjøre ytelsen synlig før De endrer noe:

Rammebudsjettet på 16 ms definerer forskjellen mellom jevn ytelse og hakking.
Android Studio Profiler viser CPU, minne og energi i sanntid.
Makro- og mikrobenchmarking gir gjentakbare tall.
Perfetto-spor og egendefinerte trace()-seksjoner viser hvor tiden går.
JankStats rapporterer hakking fra appen mens den kjører.
Les P50/P90/P99, profiler release-bygg på fysiske enheter, og endre én ting om gangen.

Deretter bruker vi dette på en av de største kildene til Compose-hakking: rekombinering.

Gratis å komme i gang

Lær deg Kotlin med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 36
Leksjoner: 152

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Måle ytelse» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Android Academy, inkludert «Måle ytelse», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Android Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Måle ytelse»?

Profileringsverktøy, spor og ytelsesmålinger. Du øver på Android Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Android Academy?

Ingen tidligere erfaring er nødvendig. Android Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Måle ytelse»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Android Academy-leksjonen?

Ja. Alle Android Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Android Academy