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

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

บทนำ

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

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

ก่อนติดต่อทีมสนับสนุน

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

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

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

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

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

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

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

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

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

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

ข้อผิดพลาดที่พบบ่อยคือ GoogleMap อาจทำให้เกิดการรั่วไหลของหน่วยความจำหากแคชโดยใช้ 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
  }
}

ยกเลิกการลงทะเบียนผู้ฟังเมื่อไม่จําเป็นต้องใช้แล้ว

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  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

  4. เลือกหน่วยความจำ

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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