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

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

บทนำ

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

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

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

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

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

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

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

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

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

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

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

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

ปล่อยการอ้างอิง GoogleMap ที่ไม่มีการอัปเดตใน GeoSDK

ข้อผิดพลาดที่พบบ่อยคือ GoogleMap อาจทำให้หน่วยความจำรั่วไหลหากแคชโดยใช้ NavigationView หรือ MapView GoogleMap มีความสัมพันธ์แบบ 1 ต่อ 1 กับ 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 สำหรับเหตุการณ์ เช่น การคลิกปุ่มหรือการเปลี่ยนแปลงสถานะของมุมมอง อย่าลืมยกเลิกการลงทะเบียน Listener เมื่อแอปพลิเคชันไม่จำเป็นต้องตรวจสอบเหตุการณ์อีกต่อไป หากไม่ทำเช่นนั้น 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

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

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

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. เลือกเปิด Heap Dump แล้วเลือกไฟล์ Heap Dump ที่คุณสร้างขึ้น เครื่องมือสร้างโปรไฟล์หน่วยความจำจะแสดงกราฟการใช้งานหน่วยความจำของแอป

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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