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

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

ตัวอย่างเช่น สมมติว่าแอปพลิเคชันใช้ Navigation SDK และเรียก Listener ต่อไปนี้เพื่อรับฟังเหตุการณ์การมาถึง: addArrivalListener method to listen for arrival events, it should also call removeArrivalListener when it no longer needs to monitor the arrival events.

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 SDK หรือ Navigation SDK นอกจากนี้ คุณยังใช้ SupportNavigationFragment หรือ SupportMapFragment แทนการใช้ NavigationView และ MapView โดยตรงได้ด้วย Support Fragment จะจัดการการส่งต่อเมธอดวงจรการทำงาน

หมายเหตุ: 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 ในแอปให้เป็นเวอร์ชันล่าสุดเพื่อรับการแก้ไขเหล่านี้

หลีกเลี่ยงการบล็อกเทรดหลักระหว่างการเริ่มต้นเพื่อป้องกัน 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 (แนะนำ)

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

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

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

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

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

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

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

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

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

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

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

   • ระบุออบเจ็กต์ที่ไม่ได้ใช้อีกต่อไป

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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