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

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

บทนำ

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

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

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

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

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

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

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

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

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

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

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

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

ปล่อยการอ้างอิง GoogleMap ที่ล้าสมัยใน GeoSDK

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

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

หมายเหตุ: NavViewActivity ในโค้ดต่อไปนี้หมายถึงกิจกรรมที่กําหนดโดยลูกค้าซึ่งคุณอาจสร้าง

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 เวอร์ชันล่าสุด

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

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

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

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

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

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

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

ขั้นตอนที่ 1: ทำให้เกิดปัญหาอีกครั้ง

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

• ฟีเจอร์ชุดใดบ้างที่เปิดใช้งานแล้ว

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

  • คุณได้ลองทำซ้ำหลายครั้งเพื่อเปิดใช้งานลำดับนี้หรือยัง

• แอปหมุนเวียนสถานะใดในวงจรชีวิต

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

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

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

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

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

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

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

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

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

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

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

• ตัวนับหน่วยความจํา Perfetto

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

• การติดตามการกําหนดราคา

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

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

ตัวนับหน่วยความจํา Perfetto

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

ยูทิลิตีบรรทัดคำสั่งดีบักบริดจ์ (adb) ของ Android

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

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

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

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

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

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

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

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

หมายเหตุ: แอป Android ที่เขียนด้วย Java หรือ Kotlin ใช้โปรแกรมเก็บขยะ (GC) เพื่อจัดการหน่วยความจำที่แอปใช้ GC จะระบุและนำออบเจ็กต์ที่ไม่ได้ใช้งานออกโดยอัตโนมัติ (นั่นคือออบเจ็กต์ที่เข้าถึงจากรูทไม่ได้) ซึ่งจะช่วยเพิ่มหน่วยความจำให้ผู้อื่นใช้ได้

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

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

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

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

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

หากต้องการบันทึกฮีปดัมป์ ให้ใช้ Android Debug Bridge (adb) หรือเครื่องมือวิเคราะห์หน่วยความจำของ Android Studio

ใช้ adb เพื่อจับภาพฮีปดัมป์

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

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

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

   • ระบุวัตถุที่ไม่ได้ใช้งานแล้ว

   • ระบุวัตถุที่ใช้หน่วยความจำมาก

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

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

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

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

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

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

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

เครื่องมือดีบักอื่นๆ

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

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

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

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

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

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

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

หมายเหตุ: เกี่ยวกับ LeakCanary และ SDK ของ Google Maps หรือการนำทาง หลังจากมีการทำลายกิจกรรมหรือส่วนที่แสดง MapView แล้ว Maps SDK หรือ Navigation SDK อาจเก็บไว้สูงสุด 1 นาทีเพื่อวัตถุประสงค์ในการบันทึก เนื่องจาก LeakCanary ตรวจพบการรั่วไหลทันทีหลังกิจกรรมหรือส่วนย่อย ถูกทำลาย โดยอาจรายงานกิจกรรมหรือส่วนย่อยว่ามีการรั่วไหล Google แนะนำให้คุณรอสัก 1 นาที แล้วบันทึกฮีปดัมป์เพื่อดู หากกิจกรรมหรือส่วนย่อยที่ถูกทำลายยังคงอยู่ในหน่วยความจำ

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

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

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

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

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

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

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

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