แนวทางปฏิบัติแนะนำเกี่ยวกับการจัดการหน่วยความจำ

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

บทนำ

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

เอกสารนี้จะให้แนวทางปฏิบัติแนะนำบางอย่างเพื่อช่วยป้องกัน ตรวจจับ และแก้ไขการรั่วไหลของหน่วยความจำในโค้ด หากคุณได้ลองใช้วิธีการในเอกสารนี้แล้วและสงสัยว่า SDK ของเรามีหน่วยความจำรั่วไหล โปรดดูวิธีรายงานปัญหาเกี่ยวกับ Google SDK

สิ่งที่ควรทำก่อนติดต่อทีมสนับสนุน

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

ป้องกันหน่วยความจำรั่ว

ทําตามแนวทางปฏิบัติแนะนําเหล่านี้เพื่อช่วยหลีกเลี่ยงสาเหตุที่พบบ่อยที่สุดบางส่วนที่ทําให้เกิด หน่วยความจำรั่วในโค้ดที่ใช้ Google SDK

แนวทางปฏิบัติแนะนำสำหรับแอป Android

ตรวจสอบว่าคุณได้ทำสิ่งต่อไปนี้ทั้งหมดในแอปพลิเคชัน Android แล้ว

  1. ปล่อยทรัพยากรที่ไม่ได้ใช้
  2. ยกเลิกการลงทะเบียน Listener เมื่อไม่ต้องการใช้แล้ว
  3. ยกเลิกงานเมื่อไม่จำเป็น
  4. ส่งต่อเมธอดวงจรเพื่อปล่อยทรัพยากร
  5. ใช้ SDK เวอร์ชันล่าสุด
  6. หลีกเลี่ยงการบล็อกเทรดหลักระหว่างการเริ่มต้นเพื่อป้องกัน ANR

โปรดดูรายละเอียดเฉพาะสำหรับแนวทางปฏิบัติแต่ละข้อในส่วนต่อไปนี้

ปล่อยทรัพยากรที่ไม่ได้ใช้

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

เผยแพร่การอ้างอิง GoogleMap ที่ล้าสมัยใน GeoSDK

ข้อผิดพลาดที่พบบ่อยคือ GoogleMap อาจทำให้เกิดการรั่วไหลของหน่วยความจำหากแคชโดยใช้ NavigationView หรือ MapView GoogleMap มีความสัมพันธ์แบบหนึ่งต่อหนึ่งกับ NavigationView หรือ MapView ที่ดึงข้อมูลมา คุณต้องตรวจสอบว่าไม่มีการแคช GoogleMap หรือปล่อยการอ้างอิงเมื่อมีการเรียก NavigationView#onDestroy หรือ MapView#onDestroy หากใช้ NavigationSupportFragment, MapSupportFragment หรือ Fragment ของคุณเองที่ ห่อหุ้มมุมมองเหล่านี้ คุณต้องปล่อยการอ้างอิงใน Fragment#onDestroyView

class NavFragment : SupportNavigationFragment() {

  var googleMap: GoogleMap?

  override fun onCreateView(
    inflater: LayoutInflater,
    parent: ViewGroup?,
    savedInstanceState: Bundle?,
  ): View  {
    super.onCreateView(inflater,parent,savedInstanceState)
    getMapAsync{map -> googleMap = map}
  }

  override fun onDestroyView() {
    googleMap = null
  }
}

ยกเลิกการลงทะเบียน Listener เมื่อไม่ต้องการใช้แล้ว

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

ตัวอย่างเช่น สมมติว่าแอปพลิเคชันของคุณใช้ Navigation SDK และเรียกใช้ Listener ต่อไปนี้เพื่อรอเหตุการณ์การมาถึง addArrivalListener เพื่อรอเหตุการณ์การมาถึง ก็ควรเรียกใช้ removeArrivalListener เมื่อไม่จําเป็นต้องตรวจสอบเหตุการณ์การมาถึงอีกต่อไป

var arrivalListener: Navigator.ArrivalListener? = null

fun registerNavigationListeners() {
  arrivalListener =
    Navigator.ArrivalListener {
      ...
    }
  navigator.addArrivalListener(arrivalListener)
}

override fun onDestroy() {
  navView.onDestroy()
  if (arrivalListener != null) {
    navigator.removeArrivalListener(arrivalListener)
  }

  ...
  super.onDestroy()
}

ยกเลิกงานเมื่อไม่ต้องการ

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

ดูรายละเอียดเพิ่มเติมเกี่ยวกับแนวทางปฏิบัติแนะนำได้ที่หัวข้อจัดการหน่วยความจำของแอป ในเอกสารประกอบของ Android

ส่งต่อเมธอดวงจรเพื่อปล่อยทรัพยากร

หากแอปใช้ SDK การนำทางหรือ Maps ให้ตรวจสอบว่าได้เผยแพร่ ทรัพยากรโดยส่งต่อเมธอดวงจร (แสดงเป็นตัวหนา) ไปยัง navView คุณทำได้โดยใช้ NavigationView ใน Navigation SDK หรือ MapView ใน Maps หรือ Navigation SDK คุณยังใช้ SupportNavigationFragment หรือ SupportMapFragment แทนการใช้ NavigationView และ MapView โดยตรงได้ด้วย ตามลำดับ Support Fragments จะจัดการการส่งต่อเมธอด Lifecycle

class NavViewActivity : AppCompatActivity() {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    ...
    navView = ...
    navView.onCreate(savedInstanceState)
    ...
  }

  override fun onSaveInstanceState(savedInstanceState: Bundle) {
    super.onSaveInstanceState(savedInstanceState)
    navView.onSaveInstanceState(savedInstanceState)
  }

  override fun onTrimMemory(level: Int) {
    super.onTrimMemory(level)
    navView.onTrimMemory(level)
  }

  /* Same with
    override fun onStart()
    override fun onResume()
    override fun onPause()
    override fun onConfigurationChanged(...)
    override fun onStop()
    override fun onDestroy()
  */
}

ใช้ SDK เวอร์ชันล่าสุด

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

หลีกเลี่ยงการบล็อกเทรดหลักระหว่างการเริ่มต้นเพื่อป้องกัน ANR

เมื่อแอปบล็อกเทรดหลักนานเกินไป อาจทำให้เกิดข้อผิดพลาด "แอปพลิเคชันไม่ตอบสนอง" (ANR) เพื่อป้องกัน ANR ให้ใช้วิธีการของวงจร เช่น onCreate() ให้มีน้ำหนักเบาที่สุดเท่าที่จะเป็นไปได้โดยการเลื่อนงานที่ใช้เวลานาน ออกไปหรือเรียกใช้จากเทรดอื่นที่ไม่ใช่เทรดหลัก

หากต้องการหลีกเลี่ยง ANR ที่เกี่ยวข้องกับการเริ่มต้น SDK ให้ทำดังนี้

  • สร้างอินสแตนซ์แผนที่ได้ครั้งละ 1 รายการเท่านั้น
  • ลดการทำงานในเทรด UI ให้มากที่สุดขณะสร้างอินสแตนซ์ของ แผนที่

แก้ไขข้อบกพร่องของหน่วยความจำรั่วไหล

หากยังคงพบปัญหาหน่วยความจำรั่วหลังจากใช้คำแนะนำที่เกี่ยวข้องทั้งหมด ก่อนหน้านี้ในเอกสารนี้ ให้ทำตามกระบวนการนี้เพื่อแก้ไขข้อบกพร่อง

ก่อนเริ่มต้นใช้งาน คุณควรทำความคุ้นเคยกับวิธีที่ Android จัดการหน่วยความจำ ดูข้อมูลได้ที่ภาพรวมของการจัดการหน่วยความจำของ Android

หากต้องการแก้ไขข้อบกพร่องของหน่วยความจำรั่ว ให้ทำตามกระบวนการต่อไปนี้

  1. จำลองการเกิดปัญหา ขั้นตอนนี้จำเป็นต่อการแก้ไขข้อบกพร่อง
  2. ตรวจสอบว่าการใช้งานหน่วยความจำเป็นไปตามที่คาดไว้หรือไม่ ตรวจสอบว่าการใช้งานที่เพิ่มขึ้นซึ่งดูเหมือนว่าจะเป็นการรั่วไหลนั้นไม่ใช่หน่วยความจำที่จำเป็นต่อการเรียกใช้แอปพลิเคชันของคุณ
  3. แก้ไขข้อบกพร่องในระดับสูง คุณใช้โปรแกรมอรรถประโยชน์หลายอย่างเพื่อแก้ไขข้อบกพร่องได้ ชุดเครื่องมือมาตรฐาน 3 ชุดที่แตกต่างกันช่วยแก้ไขข้อบกพร่องเกี่ยวกับปัญหาหน่วยความจำใน Android ได้แก่ Android Studio, Perfetto และยูทิลิตีบรรทัดคำสั่ง Android Debug Bridge (adb)
  4. ตรวจสอบการใช้หน่วยความจำของแอป รับฮีปดัมป์และติดตามการจัดสรร แล้ววิเคราะห์
  5. แก้ไขการรั่วไหลของหน่วยความจำ

ส่วนต่อไปนี้จะอธิบายขั้นตอนเหล่านี้โดยละเอียด

ขั้นตอนที่ 1: ทำซ้ำปัญหา

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

  • ระบบจะเปิดใช้งานฟีเจอร์ชุดใด

  • ลำดับการกระทำของผู้ใช้ที่เฉพาะเจาะจงใดที่ทำให้เกิดการรั่วไหล

    • คุณได้ลองเปิดใช้งานลำดับนี้หลายครั้งแล้วใช่ไหม

  • แอปผ่านสถานะวงจรการใช้งานใดมาบ้าง

    • คุณได้ลองทำซ้ำหลายครั้งผ่านสถานะวงจรที่แตกต่างกันแล้วหรือยัง

ตรวจสอบว่าคุณสามารถจำลองปัญหาใน SDK เวอร์ชันล่าสุดได้ ปัญหาจากเวอร์ชันก่อนหน้าอาจได้รับการแก้ไขแล้ว

ขั้นตอนที่ 2: ตรวจสอบว่าการใช้งานหน่วยความจำของแอปเป็นไปตามที่คาดไว้หรือไม่

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

  • มีแนวโน้มที่จะเกิดการรั่วไหล: การเปิดใช้งานสถานการณ์ผ่านการทำซ้ำหลายครั้ง ส่งผลให้การใช้งานหน่วยความจำเพิ่มขึ้นเมื่อเวลาผ่านไป

  • การใช้งานหน่วยความจำที่คาดไว้: ระบบจะเรียกคืนหน่วยความจำหลังจากหยุดสถานการณ์

  • การใช้งานหน่วยความจำที่อาจคาดการณ์ได้: การใช้งานหน่วยความจำจะเพิ่มขึ้นในช่วงระยะเวลาหนึ่ง แล้วค่อยๆ ลดลง ซึ่งอาจเกิดจากแคชที่มีขอบเขตหรือการใช้งานหน่วยความจำอื่นๆ ที่คาดการณ์ได้

หากลักษณะการทำงานของแอปน่าจะเป็นการใช้หน่วยความจำตามที่คาดไว้ คุณสามารถแก้ไขปัญหาได้โดยการจัดการการใช้งานหน่วยความจำของแอป ดูความช่วยเหลือได้ที่หัวข้อจัดการหน่วยความจำของแอป

ขั้นตอนที่ 3: แก้ข้อบกพร่องในระดับสูง

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

เครื่องมือสร้างโปรไฟล์หน่วยความจำของ Android Studio

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

ตัวนับหน่วยความจำของ Perfetto

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

อินเทอร์เฟซผู้ใช้ Perfetto

ยูทิลิตีบรรทัดคำสั่ง Android Debug Bridge (adb)

ข้อมูลส่วนใหญ่ที่คุณติดตามได้ด้วย Perfetto ยังมีให้ใช้งานเป็นadb ยูทิลิตีบรรทัดคำสั่งที่คุณค้นหาได้โดยตรงด้วย ตัวอย่างที่สำคัญ มีดังนี้

  • Meminfo ช่วยให้คุณ ดูข้อมูลหน่วยความจำโดยละเอียด ณ จุดใดจุดหนึ่งได้

  • Procstats ให้ข้อมูล สถิติรวมที่สำคัญบางอย่างเมื่อเวลาผ่านไป

สถิติที่สำคัญซึ่งควรดูในที่นี้คือหน่วยความจำที่ใช้จริงสูงสุด (maxRSS) ที่แอปต้องการเมื่อเวลาผ่านไป MaxPSS อาจไม่แม่นยำเท่า ดูวิธีเพิ่มความแม่นยำได้ที่adb shell dumpsys procstats --help –start-testing

การติดตามการจัดสรร

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

ขั้นตอนที่ 4: ตรวจสอบการใช้หน่วยความจำของแอปด้วยฮีปดัมป์

วิธีหนึ่งในการตรวจหาหน่วยความจำรั่วไหลคือการรับฮีปดัมป์ของแอป แล้วตรวจสอบการรั่วไหล ฮีปดัมป์คือสแนปชอตของออบเจ็กต์ทั้งหมด ในหน่วยความจำของแอป ซึ่งใช้เพื่อวินิจฉัยปัญหาหน่วยความจำรั่วและปัญหาอื่นๆ ที่เกี่ยวข้องกับหน่วยความจำได้

Android Studio สามารถตรวจหาหน่วยความจำรั่วที่ GC แก้ไขไม่ได้ เมื่อคุณบันทึกฮีปดัมป์ Android Studio จะตรวจสอบว่ามีกิจกรรมหรือ Fragment ที่ยังเข้าถึงได้แต่ถูกทำลายไปแล้วหรือไม่

  1. บันทึกฮีปดัมป์
  2. วิเคราะห์ฮีปดัมป์เพื่อหารอยรั่วของหน่วยความจำ
  3. แก้ไขปัญหาหน่วยความจำรั่วไหล

โปรดดูรายละเอียดที่หัวข้อด้านล่าง

บันทึกฮีปดัมป์

หากต้องการบันทึกฮีปดัมป์ คุณสามารถใช้ Android Debug Bridge (adb) หรือเครื่องมือสร้างโปรไฟล์หน่วยความจำของ Android Studio

ใช้ adb เพื่อบันทึกฮีปดัมป์

หากต้องการบันทึกฮีปดัมป์โดยใช้ adb ให้ทำตามขั้นตอนต่อไปนี้

  1. เชื่อมต่ออุปกรณ์ Android กับคอมพิวเตอร์
  2. เปิด Command Prompt แล้วไปที่ไดเรกทอรีที่มีเครื่องมือ adb

  3. หากต้องการบันทึกฮีปดัมป์ ให้เรียกใช้คำสั่งต่อไปนี้

    adb shell am dumpheap my.app.name $PHONE_FILE_OUT

  4. หากต้องการดึงข้อมูลฮีปดัมป์ ให้เรียกใช้คำสั่งต่อไปนี้

    adb pull $PHONE_FILE_OUT $LOCAL_FILE.

ใช้ Android Studio เพื่อบันทึกฮีปดัมป์

หากต้องการบันทึกฮีปดัมป์โดยใช้เครื่องมือสร้างโปรไฟล์หน่วยความจำของ Android Studio ให้ทำตามขั้นตอนในส่วน บันทึกฮีปดัมป์ ของ Android

วิเคราะห์ฮีปดัมป์เพื่อหารอยรั่วของหน่วยความจำ

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

  1. เปิดโปรเจ็กต์ Android ใน Android Studio

  2. เลือกเรียกใช้ แล้วเลือกการกำหนดค่าแก้ไขข้อบกพร่อง

  3. เปิดแท็บ Android Profiler

  4. เลือกความทรงจำ

  5. เลือกเปิดฮีปดัมป์ แล้วเลือกไฟล์ฮีปดัมป์ที่คุณสร้างขึ้น Memory Profiler จะแสดงกราฟการใช้งานหน่วยความจำของแอป

  6. ใช้กราฟเพื่อวิเคราะห์ฮีปดัมป์ดังนี้

    • ระบุออบเจ็กต์ที่ไม่ได้ใช้งานแล้ว

    • ระบุออบเจ็กต์ที่ใช้หน่วยความจำมาก

    • ดูว่าออบเจ็กต์แต่ละรายการใช้หน่วยความจำมากเพียงใด

  7. ใช้ข้อมูลนี้เพื่อจำกัดหรือค้นหาแหล่งที่มาของหน่วยความจำรั่วไหลและแก้ไข

ขั้นตอนที่ 5: แก้ไขปัญหาหน่วยความจำรั่วไหล

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

เครื่องมือแก้ไขข้อบกพร่องอื่นๆ

หลังจากทำตามขั้นตอนเหล่านี้แล้ว หากยังไม่พบและแก้ไข หน่วยความจำรั่วไหล ให้ลองใช้เครื่องมือต่อไปนี้

แก้ไขข้อบกพร่องของหน่วยความจำในโค้ดแบบเนทีฟด้วยการติดตามการจัดสรร

แม้ว่าคุณจะไม่ได้ใช้โค้ดแบบเนทีฟโดยตรง แต่ไลบรารี Android ทั่วไปหลายรายการ ก็ใช้ รวมถึง SDK ของ Google หากคิดว่าหน่วยความจำรั่วไหลอยู่ในโค้ดแบบเนทีฟ คุณสามารถใช้เครื่องมือหลายอย่าง เพื่อแก้ไขข้อบกพร่องได้ การติดตามการจัดสรรด้วย Android Studio หรือ heapprofd (ใช้ได้กับ Perfetto ด้วย) เป็นวิธีที่ยอดเยี่ยมในการระบุสาเหตุที่อาจทำให้เกิดหน่วยความจำรั่วไหล และมักเป็นวิธีที่เร็วที่สุดในการแก้ไขข้อบกพร่อง

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

ระบุการรั่วไหลด้วย LeakCanary

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

วิธีรายงานปัญหาเกี่ยวกับ Google SDK

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

  • ขั้นตอนในการจำลองปัญหาหน่วยความจำรั่วไหล หากขั้นตอนต้องใช้การเขียนโค้ดที่ซับซ้อน การคัดลอกโค้ดที่จำลองปัญหาลงในแอปตัวอย่างของเรา และระบุขั้นตอนเพิ่มเติมที่ต้องดำเนินการใน UI เพื่อทริกเกอร์ การรั่วไหลอาจช่วยได้

  • Heap Dump ที่บันทึกจากแอปของคุณโดยจำลองปัญหาขึ้นใหม่ บันทึกฮีปดัมป์ใน 2 ช่วงเวลาที่แตกต่างกันซึ่งแสดงให้เห็นว่าการใช้งานหน่วยความจำเพิ่มขึ้นอย่างมาก

  • หากคาดว่าจะมีหน่วยความจำรั่วไหลในโค้ดเนทีฟ ให้แชร์เอาต์พุตการติดตามการจัดสรรจาก heapprofd

  • รายงานข้อบกพร่องที่สร้างขึ้นหลังจากที่คุณจำลองเงื่อนไขการรั่วไหลอีกครั้ง

  • สแต็กเทรซของข้อขัดข้องที่เกี่ยวข้องกับหน่วยความจำ

    หมายเหตุสำคัญ: โดยปกติแล้ว สแต็กเทรซเพียงอย่างเดียวไม่เพียงพอต่อการ แก้ไขข้อบกพร่องเกี่ยวกับปัญหาหน่วยความจำ ดังนั้นโปรดระบุข้อมูลในรูปแบบอื่นๆ ด้วย