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

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

บทนำ

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

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

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

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

ตัวอย่างเช่น สมมติว่าแอปพลิเคชันของคุณใช้ 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

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

หากแอปใช้การนำทางหรือ 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 เวอร์ชันล่าสุด

เราอัปเดต 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 Memory Counter

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

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

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

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

  • Procstats จะแสดงสถิติรวมที่สำคัญบางประการเมื่อเวลาผ่านไป

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

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

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

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

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

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

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

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

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

ในการจับภาพฮีปดัมป์ คุณสามารถใช้ Android Debug Bridge (adb) หรือ Android Studio Memory Profiler

ใช้ 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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