Android Academy · บทเรียน

การวัดประสิทธิภาพ

เครื่องมือวิเคราะห์ การติดตาม และการทดสอบประสิทธิภาพ

การวัดประสิทธิภาพ เป็นบทเรียน Android Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Android Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Android Academy มีบทเรียนทั้งหมด 4 บทเรียน

วัดผลก่อนปรับให้เหมาะสม

กฎทองของการปรับปรุงประสิทธิภาพคือ วัดผลก่อน อย่าเดา สัญชาตญาณของมนุษย์เกี่ยวกับสิ่งที่ทำงานช้ามักผิดเกือบทุกครั้ง

ในบทเรียนนี้ คุณจะเรียนรู้เครื่องมือที่ Android มอบให้เพื่อ มองเห็นประสิทธิภาพ ได้แก่ เครื่องมือวิเคราะห์ประสิทธิภาพ การติดตามระบบ และการวัดประสิทธิภาพระดับย่อย เมื่อคุณวัดผลได้ การปรับปรุงทุกครั้งจะกลายเป็นการตัดสินใจที่อิงข้อมูล แทนที่จะเป็นเพียงการคาดเดา

เครื่องมือวิเคราะห์ประสิทธิภาพแสดงการใช้ CPU หน่วยความจำ และพลังงานแบบเรียลไทม์
การติดตามระบบเปิดเผยอย่างชัดเจนว่าเวลาในแต่ละเฟรมถูกใช้ไปที่ใด
การวัดประสิทธิภาพให้ตัวเลขที่ทำซ้ำได้และเปรียบเทียบระหว่างการสร้างแต่ละครั้งได้

งบประมาณเฟรม 16 มิลลิวินาที

บนหน้าจอ 60Hz ระบบจะแสดงเฟรมใหม่ทุก ๆ 16.67ms หากแอปของคุณเตรียมเฟรมไม่เสร็จภายในช่วงเวลานี้ เฟรมจะถูกทิ้ง และผู้ใช้จะรับรู้ได้ถึงอาการ กระตุก (ภาพสะดุด) บนอุปกรณ์ 120Hz งบประมาณนี้จะลดลงเหลือประมาณ 8ms

การปรับปรุงประสิทธิภาพแท้จริงแล้วคือการทำงานให้อยู่ภายในงบประมาณนี้ ความคิดเห็นด้านล่างแสดงการคำนวณที่คุณควรคำนึงไว้เสมอ

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

ตัววิเคราะห์ประสิทธิภาพของ Android Studio (มุมมอง > หน้าต่างเครื่องมือ > ตัววิเคราะห์ประสิทธิภาพ) จะเชื่อมต่อกับแอปที่กำลังทำงานและแสดงเส้นเวลาสดของ CPU หน่วยความจำ พลังงาน และเครือข่าย

CPU: บันทึกการติดตามเมธอดและการติดตามระบบเพื่อค้นหาเส้นทางการทำงานที่เป็นคอขวด
หน่วยความจำ: เฝ้าดูการจัดสรรหน่วยความจำและบันทึกภาพฮีปเพื่อค้นหาการรั่วไหล
พลังงาน: ตรวจหาการล็อกไม่ให้เครื่องหลับและงานที่มากเกินไปจนทำให้แบตเตอรี่หมด

ควรวิเคราะห์ประสิทธิภาพของ รุ่นบิลด์แบบรีลีส บน อุปกรณ์จริง เสมอ บิลด์สำหรับแก้ไขข้อผิดพลาดและโปรแกรมจำลองให้ตัวเลขที่ทำให้เข้าใจผิด เพราะไม่ได้เปิดใช้การปรับให้เหมาะสม

การวัดประสิทธิภาพระดับแมโครสำหรับสถานการณ์จริง

ไลบรารี Jetpack Macrobenchmark วัดเส้นทางการใช้งานทั้งหมด (การเริ่มต้น การเลื่อน และการนำทาง) บนอุปกรณ์จริง และรายงานตัวชี้วัดที่คงที่ เช่น เวลาแสดงเฟรมและเวลาเริ่มต้น

คุณเขียนการทดสอบที่เปิดแอปและดำเนินขั้นตอนการใช้งาน จากนั้นไลบรารีจะทำซ้ำหลายครั้งและให้ค่ามัธยฐานกับค่าเปอร์เซ็นไทล์ที่ 99

@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 ไลบรารีจะเรียกใช้โค้ดของคุณในลูปที่กระชับ ทำให้ JIT อุ่นเครื่อง และรายงานจำนวนนาโนวินาทีต่อการทำงานหนึ่งครั้งโดยตัดสัญญาณรบกวนออก

ใช้กับตัวแยกวิเคราะห์ ตัวจัดลำดับ การเรียงลำดับ หรือฟังก์ชันช่วยที่ใช้ CPU และถูกเรียกบ่อย

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

การติดตามระบบด้วย Perfetto

การติดตามระบบ จะบันทึกสิ่งที่ทุกเธรดและระบบทำในแต่ละเฟรม ตัววิเคราะห์ CPU ของ Android Studio สามารถบันทึกได้ และคุณยังบันทึกด้วย adb แล้วเปิดใน Perfetto (ui.perfetto.dev) ได้ด้วย

การติดตามจะแสดงเฟรมสีแดงที่น่าหวาดหวั่น งานบนเธรดหลัก และเวลาที่ใช้ใน GPU นี่คือเครื่องมือที่ดีที่สุดเพียงหนึ่งเดียวสำหรับวินิจฉัยอาการกระตุก

# 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

ส่วนการติดตามแบบกำหนดเอง

โดยค่าเริ่มต้น การติดตามจะแสดงงานของเฟรมเวิร์ก หากต้องการติดป้ายกำกับโค้ด ของคุณเอง ให้ครอบโค้ดไว้ในส่วนการติดตามที่ตั้งชื่อ ส่วนเหล่านี้จะแสดงเป็นบล็อกที่มีป้ายกำกับใน Perfetto ทำให้มองเห็นจุดคอขวดได้ง่าย

ใช้ API androidx.tracing เพื่อให้ส่วนเหล่านี้ปรากฏทั้งในการติดตามสำหรับการแก้ไขข้อผิดพลาดและการติดตามการวัดประสิทธิภาพ

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

การติดตามเฟรมที่ถูกทิ้งขณะรันไทม์

คุณไม่ได้เชื่อมต่อตัววิเคราะห์ประสิทธิภาพไว้เสมอไป JankStats เป็นไลบรารี Jetpack ที่รายงานเฟรมซึ่งกระตุกจากภายในแอปที่กำลังทำงาน คุณจึงสามารถบันทึกหรือส่งข้อมูลรวมไปยังระบบวิเคราะห์ได้

ไลบรารีนี้เชื่อมต่อกับหน้าต่างและเรียกกลับหาคุณทุกครั้งที่เฟรมใช้เวลาเกินงบประมาณ

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 }

อ่านตัวเลข: ค่าเปอร์เซ็นไทล์

ค่าเฉลี่ยเพียงค่าเดียวอาจซ่อนปัญหาไว้ หากเฟรมโดยเฉลี่ยใช้เวลา 10ms แต่ เปอร์เซ็นไทล์ที่ 99 อยู่ที่ 40ms นั่นหมายความว่า 1% ของเฟรมกระตุก และผู้ใช้สัมผัสได้ ควรดู P50, P90, P99 เสมอ ไม่ใช่ดูแค่ค่าเฉลี่ย

การวัดประสิทธิภาพจะรายงานค่าเหล่านี้ให้คุณ ตัวช่วยด้านล่างแสดงแนวคิดนี้กับตัวอย่างเฟรมดิบ

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

กระบวนการวัดผลที่ทำซ้ำได้

ตัวเลขที่เชื่อถือได้มาจากกระบวนการที่มีวินัย ทำตามรายการตรวจสอบนี้ทุกครั้ง:

ใช้บิลด์ รีลีส / แก้ไขข้อผิดพลาดไม่ได้ (เปิดใช้ R8)
ทำงานบน อุปกรณ์จริง ที่เสียบปลั๊กและมีสถานะความร้อนคงที่
ทำซ้ำสถานการณ์หลายครั้งและรายงานค่ามัธยฐาน
เปลี่ยน ทีละอย่าง แล้ววัดใหม่
เปรียบเทียบกับ ค่าพื้นฐาน ที่บันทึกไว้เพื่อยืนยันการปรับปรุง

หากข้ามขั้นตอนเหล่านี้ คุณจะเสียเวลาไล่ตามสัญญาณรบกวนแทนที่จะแก้ปัญหาจริง

เวลาถูกใช้ไปที่ใดกันแน่

อาการกระตุกส่วนใหญ่ของ Android เกิดจากสาเหตุไม่กี่อย่าง การรู้จักสาเหตุเหล่านี้จะบอกคุณว่าควรใช้เครื่องมือมุ่งตรวจสอบที่ใด:

งานบนเธรดหลัก: ดิสก์/เครือข่าย/JSON บนเธรด UI
การจัดองค์ประกอบใหม่มากเกินไป: Compose วาดใหม่มากเกินความจำเป็น
การจัดสรรหน่วยความจำถี่เกินไป: การหยุดชั่วคราวของการเก็บขยะ
รอบการจัดวาง: การจัดวางที่ซ้อนกันลึกหรือถูกวัดซ้ำหลายครั้ง

บทเรียนถัดไปของหลักสูตรนี้จะจัดการกับการจัดองค์ประกอบใหม่ การรั่วไหลของหน่วยความจำ และการเริ่มต้นโดยตรง การวัดผลจะบอกคุณว่าควรแก้สิ่งใดก่อน

ตรวจสอบอย่างรวดเร็ว

คุณต้องการวัดเวลาที่แอปใช้ในการ เริ่มต้นแบบเย็น บนอุปกรณ์จริงอย่างคงที่และทำซ้ำได้ในหลายรอบ เครื่องมือใดเหมาะที่สุด

สรุป: ตอนนี้คุณวัดผลได้แล้ว

คุณได้เรียนรู้วิธีทำให้ประสิทธิภาพ มองเห็นได้ ก่อนเปลี่ยนแปลงสิ่งใด:

งบประมาณเฟรม 16ms เป็นตัวกำหนดว่าการทำงานจะลื่นไหลหรือกระตุก
ตัววิเคราะห์ประสิทธิภาพของ Android Studio แสดง CPU หน่วยความจำ และพลังงานแบบสด
การวัดประสิทธิภาพระดับ แมโคร และ ไมโคร ให้ตัวเลขที่ทำซ้ำได้
การติดตามของ Perfetto และส่วน trace() แบบกำหนดเองเผยให้เห็นว่าเวลาใช้ไปที่ใด
JankStats รายงานอาการกระตุกจากภายในแอปที่กำลังทำงาน
อ่านค่า P50/P90/P99 วิเคราะห์บิลด์รีลีสบนอุปกรณ์จริง และเปลี่ยนทีละอย่าง

ต่อไป เราจะนำสิ่งนี้ไปใช้กับหนึ่งในสาเหตุใหญ่ที่สุดของอาการกระตุกใน Compose นั่นคือการจัดองค์ประกอบใหม่

คำถามที่พบบ่อย

บทเรียน “การวัดประสิทธิภาพ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การวัดประสิทธิภาพ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Android Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Android Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การวัดประสิทธิภาพ”

เครื่องมือวิเคราะห์ การติดตาม และการทดสอบประสิทธิภาพ คุณปฏิบัติ Android Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Android Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Android Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “การวัดประสิทธิภาพ” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Android Academy นี้ได้ไหม

ได้ บทเรียน Android Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Android Academy