การเชื่อมโยงบริการและสถานะกระบวนการ

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

สถานะกระบวนการและคะแนน OOM

เฟรมเวิร์ก Android ใช้สถานะกระบวนการเพื่อติดตามความสำคัญของแต่ละกระบวนการที่ทำงานอยู่ จากนั้น OomAdjuster จะใช้สถานะเหล่านี้เพื่อกำหนดค่าการปรับคะแนน OOM (oom_score_adj) ซึ่งมีค่าตั้งแต่ -1000 ถึง 1000

oom_score_adj ที่ต่ำกว่าหมายความว่ากระบวนการมีความสำคัญมากกว่าและมีแนวโน้มที่จะถูกหยุดโดย Low Memory Killer (LMK) น้อยกว่า

สถานะกระบวนการทั่วไป

ตารางต่อไปนี้แสดงสถานะกระบวนการที่พบบ่อยที่สุดบางส่วนและค่า oom_score_adj ทั่วไป ดูรายการทั้งหมดและรายการล่าสุดได้ที่ android.app.ActivityManager และ com.android.server.am.psc.Constants ในซอร์สโค้ดของ Android

รัฐ (ตัวย่อ) คำอธิบาย oom_score_adjปกติ
PER (ถาวร) กระบวนการของระบบที่ต้องทำงานอยู่เสมอ (เช่น โทรศัพท์) -800
TOP กระบวนการที่ผู้ใช้กำลังโต้ตอบอยู่ 0
VIS (มองเห็นได้) กระบวนการมีกิจกรรมที่มองเห็นได้ (เช่น อยู่หลังกล่องโต้ตอบแบบโปร่งแสง) 100
PERC (Perceptible) กระบวนการเบื้องหลังที่ผู้ใช้ทราบ (เช่น การเล่นเพลง) 200
FGS กระบวนการที่โฮสต์บริการที่ทำงานอยู่เบื้องหน้า 0 ถึง 200 (แตกต่างกันไป)
BTOP (ขอบบน) กระบวนการที่เชื่อมโยงกับแอปพลิเคชัน TOP 100
BFGS บริการที่ทำงานอยู่เบื้องหน้าที่เชื่อมโยง (โดยปกติจะเชื่อมโยงกับระบบ) 0
PREV (ก่อนหน้า) กระบวนการล่าสุดที่ผู้ใช้อยู่ก่อนกระบวนการปัจจุบัน 700
CACHED แอปที่ทำงานอยู่เบื้องหลังซึ่งสามารถปิดได้อย่างปลอดภัย 900 ถึง 999

ผลกระทบของการผูกบริการ

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

กระบวนการ A เชื่อมโยงกับกระบวนการ B ซึ่งจะยกระดับกระบวนการ B เป็น BTOP
รูปที่ 1 การรับค่าลำดับความสำคัญในการผูกบริการ

การควบคุมการรับค่าด้วยแฟล็ก BIND

การรับค่าเป็นลักษณะการทำงานเริ่มต้นเมื่อใช้ Context.BIND_AUTO_CREATE อย่างไรก็ตาม นักพัฒนาแอปสามารถควบคุมผลกระทบของการเชื่อมโยงที่มีต่อความสำคัญของกระบวนการเป้าหมายได้โดยใช้แฟล็กต่างๆ ใน bindService()

แฟล็ก BIND ที่สำคัญสำหรับคะแนน OOM

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

  • BIND_AUTO_CREATE: แฟล็กที่พบบ่อยที่สุด ซึ่งจะช่วยให้มั่นใจได้ว่ากระบวนการของบริการจะเริ่มต้นและทำงานต่อไปตราบใดที่ยังมีการเชื่อมโยงอยู่ โดยค่าเริ่มต้น ระบบจะยกระดับลำดับความสำคัญของกระบวนการเซิร์ฟเวอร์ให้ตรงกับไคลเอ็นต์ด้วย
  • BIND_NOT_FOREGROUND: ป้องกันไม่ให้กระบวนการของบริการเป้าหมายถูกยกระดับเป็นลำดับความสำคัญการจัดกำหนดการเบื้องหน้า (ลำดับความสำคัญของ CPU) อย่างไรก็ตาม วิธีนี้ยังคงอนุญาตให้ยกระดับลำดับความสำคัญของหน่วยความจำ (oom_score_adj) ได้ ซึ่งจะเป็นประโยชน์สำหรับงานเบื้องหลังที่ไม่ควรแย่งรอบการทำงานของ CPU กับ UI แต่ก็ยังควรได้รับการป้องกันไม่ให้ถูกปิด
  • BIND_WAIVE_PRIORITY: แฟล็กที่สำคัญมากซึ่งจะสั่งให้ระบบไม่ส่งผลต่อลำดับความสำคัญของการกำหนดเวลาหรือการจัดการหน่วยความจำของกระบวนการเป้าหมาย ระบบจะจัดการกระบวนการของบริการเสมือนว่าเป็นกระบวนการเบื้องหลังปกติในรายการ LRU ซึ่งทำให้มีสิทธิ์ถูก OOM ปิดแม้ว่าจะเชื่อมโยงอยู่ก็ตาม
  • BIND_ABOVE_CLIENT: บ่งชี้ว่าบริการมีความสำคัญมากกว่าแอปไคลเอ็นต์เอง เมื่อระบบต้องการเรียกคืนหน่วยความจำ ระบบจะเลือกปิดแอปไคลเอ็นต์ก่อนปิดบริการที่มีผลผูกพัน ซึ่ง "ปลอดภัยกว่า" BIND_AUTO_CREATE เนื่องจากมีการปกป้องอีกชั้นหนึ่งสำหรับบริการโดยแลกกับค่าใช้จ่ายของไคลเอ็นต์
  • BIND_NOT_PERCEPTIBLE: ลดความสำคัญของบริการเป้าหมายให้อยู่ต่ำกว่าระดับ PERCEPTIBLE ซึ่งช่วยให้ระบบเรียกคืนหน่วยความจำเพื่อเพิ่มพื้นที่ว่างสำหรับกระบวนการที่สำคัญยิ่งขึ้นซึ่งผู้ใช้รับรู้ได้

การลงมือปฏิบัติ: การสังเกตผลกระทบของการเชื่อมโยง

ขั้นตอนต่อไปนี้ใช้แอป MemoryLab เพื่อแสดงให้เห็นว่าการเชื่อมโยงจากแอป TOP ส่งผลต่อสถานะของกระบวนการแยกต่างหากอย่างไร

1. เปิด MemoryLab

คำสั่งต่อไปนี้จะเปิดแอป หลังจากเปิดแล้ว ตรวจสอบว่าแอปยังคงทำงานอยู่เบื้องหน้า (อย่าเพิ่งกดปุ่มหน้าแรกหรือเปลี่ยนแอป)

adb shell am start -n com.android.memorylab/.MainActivity

2. ระบุกระบวนการ

ตรวจสอบสถานะกระบวนการก่อนเชื่อมโยง MemoryLab เรียกใช้ UI หลักในกระบวนการเดียวและมี RemoteService ที่ทำงานในกระบวนการ :remote

adb shell dumpsys activity processes com.android.memorylab

ตัวอย่างข้อมูลโค้ดเอาต์พุต

  Process OOM control (154 total, non-act at 7, non-svc at 7):
    Proc #0: fg       T/A/TOP  LCMNFUATI  t: 0 13470:com.android.memorylab/u0a417 (top-activity)
        oom: max=1001 curRaw=0 setRaw=0 cur=0 set=0
        state: cur=TOP  set=TOP   lastRss=0.00 lastCachedRss=0.00

คุณจะเห็นกระบวนการหลัก com.android.memorylab ในสถานะ TOP ยังไม่ได้เริ่มกระบวนการ:remote

3. การเชื่อมโยงทริกเกอร์

ส่งการออกอากาศไปยังแอปเพื่อทริกเกอร์การผูกบริการ

adb shell am broadcast -a com.android.memorylab.LEAK_BINDER

4. สังเกตสถานะที่ยกระดับ

ตรวจสอบสถานะกระบวนการอีกครั้ง โดยทำดังนี้

adb shell dumpsys activity processes | grep -A 10 "com.android.memorylab"

ตัวอย่างข้อมูลโค้ดเอาต์พุต

  Proc #  1: vis      F/ /BTOP ---NFUATI  t: 0 13560:com.android.memorylab:remote/u0a417 (service)
    com.android.memorylab/.RemoteService<=Proc{13470:com.android.memorylab/u0a417}
    oom: max=1001 curRaw=100 setRaw=100 cur=100 set=100
    state: cur=BTOP set=BTOP  lastRss=0.00 lastCachedRss=0.00

ตอนนี้กระบวนการ :remote กำลังทำงานและอยู่ในสถานะ BTOP (Bound TOP) โดยมี oom_score_adj เท่ากับ 100 ซึ่งได้รับการปกป้องมากกว่าบริการที่ทำงานอยู่เบื้องหลังทั่วไปอย่างมาก (ซึ่งจะอยู่ที่ 500 ขึ้นไป) สัญลักษณ์ <=Proc{...} แสดงให้เห็นว่ากระบวนการใดเป็นผู้รับผิดชอบในการยกระดับความสำคัญนี้

5. ส่งไปที่พื้นหลัง

กดปุ่มหน้าแรกบนอุปกรณ์ ตรวจสอบสถานะอีกครั้งโดยทำดังนี้

adb shell dumpsys activity processes | grep -A 10 "com.android.memorylab"

ตัวอย่างข้อมูลโค้ดเอาต์พุต

    Proc #  2: prev     b/ /LAST --------I  t: 0 13560:com.android.memorylab:remote/u0a417 (service)
        com.android.memorylab/.RemoteService<=Proc{13470:com.android.memorylab/u0a417}
        oom: max=1001 curRaw=700 setRaw=700 cur=700 set=700
        state: cur=LAST set=LAST  lastRss=0.00 lastCachedRss=0.00
    Proc #  1: prev     b/ /LAST --------I  t: 0 13470:com.android.memorylab/u0a417 (previous)
        oom: max=1001 curRaw=700 setRaw=700 cur=700 set=700
        state: cur=LAST set=LAST  lastRss=209MB lastCachedRss=0.00

ตอนนี้ทั้ง 2 กระบวนการได้เปลี่ยนไปอยู่ในสถานะที่มีลำดับความสำคัญต่ำลง (PREV / oom_score_adj 700) เนื่องจากกระบวนการของไคลเอ็นต์ไม่ได้TOPอีกต่อไป (หมายเหตุ: LAST ในดัมพ์สถานะหมายถึงสถานะภายใน LAST_ACTIVITY ซึ่งแมปกับ PREV ในสรุประดับสูง)

กำลังวิเคราะห์ด้วย procstats

เครื่องมือ procstats จะแสดงมุมมองย้อนหลังของสถานะเหล่านี้

# View stats for MemoryLab over the last hour
adb shell dumpsys procstats --hours 1 com.android.memorylab

ตัวอย่างข้อมูลโค้ดเอาต์พุต

  *   com.android.memorylab / u0a417 / v37:
      *   Prc com.android.memorylab / u0a417 / v37:
             TOTAL: 0.89% (0.00-0.00-0.00/0.00-0.00-0.00/210MB-210MB-210MB over 1)
               Top: 0.89% (0.00-0.00-0.00/0.00-0.00-0.00/210MB-210MB-210MB over 1)
      *   Prc com.android.memorylab:remote / u0a417 / v37:
             TOTAL: 0.19%
           Bnd Top: 0.19%

ในที่นี้ Bnd Top หมายถึงเปอร์เซ็นต์ของเวลาที่กระบวนการระยะไกลใช้ไปกับการเชื่อมโยงกับแอปพลิเคชันในสถานะ TOP

การบันทึกและวิเคราะห์การเชื่อมโยงด้วย Perfetto

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

1. บันทึกการติดตาม

ใช้การกำหนดค่าที่มี linux.process_stats และหมวดหมู่ atrace am ดังนี้

adb shell perfetto -c - --txt -o /data/misc/perfetto-traces/service_bindings.perfetto-trace <<EOF
buffers: { size_kb: 65536 }
data_sources: {
    config {
        name: "linux.process_stats"
        process_stats_config { proc_stats_poll_ms: 100 }
    }
}
data_sources: {
    config {
        name: "linux.ftrace"
        ftrace_config { ftrace_events: "am/am_proc_bound" }
    }
}
duration_ms: 15000
EOF

2. การเปลี่ยนคะแนน OOM ของการค้นหา

เมื่อใช้ PerfettoSQL คุณจะเห็นว่าคะแนน OOM ของกระบวนการระยะไกลเปลี่ยนแปลงไปอย่างไรเมื่อเทียบกับกระบวนการ UI ดังนี้

SELECT ts, p.name, value AS oom_score_adj
FROM counter c
JOIN process_counter_track t ON c.track_id = t.id
JOIN process p USING (upid)
WHERE p.name LIKE 'com.android.memorylab%'
  AND t.name = 'oom_score_adj'
ORDER BY ts;

3. ระบุกิจกรรมการเชื่อมโยง

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

SELECT
    s.ts,
    p.name AS process_name,
    t.name AS thread_name,
    s.name AS slice_name
FROM slice s
JOIN thread_track tt ON s.track_id = tt.id
JOIN thread t USING (utid)
JOIN process p USING (upid)
WHERE s.name LIKE 'bindService:{com.android.memorylab%';

การเชื่อมโยงระบบกับแอป

ระบบ Android เองมักจะเชื่อมโยงกับบริการในแอปของบุคคลที่สามเพื่อให้บริการฟังก์ชันหลัก โดยปกติแล้ว เป้าหมายของการเชื่อมโยงเหล่านี้คือการลดเวลาในการตอบสนอง การคงกระบวนการให้ทำงานอยู่และอยู่ในหน่วยความจำจะช่วยให้ระบบหลีกเลี่ยงค่าใช้จ่ายที่สูงเกินไปของ "Cold Start" (การโหลด APK, การเริ่มต้นรันไทม์ และการสร้างออบเจ็กต์แอปพลิเคชัน) เมื่อเกิดการโต้ตอบที่สำคัญของผู้ใช้ การเชื่อมโยงอื่นๆ มีไว้เพื่อป้องกันการเริ่มใหม่บ่อยครั้งสำหรับแอปที่ต้องจัดการสตรีมของเหตุการณ์ในเบื้องหลัง

ตัวอย่างจริงที่คุณสังเกตได้ในอุปกรณ์ทั่วไปมีดังนี้

VoiceInteractionService

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

เมื่อเกิดทริกเกอร์ผู้ช่วย (เช่น คำสั่ง "Ok Google" ในโทรศัพท์ Google Pixel) ผู้ช่วยดิจิทัลจะต้องตอบสนองทันที เพื่อให้เป็นไปตามนี้ system_server จะคงการเชื่อมโยงถาวรกับ VoiceInteractionService ที่ผู้ใช้เลือกไว้

system_server จะเชื่อมโยงกับกระบวนการของโปรแกรมโต้ตอบอย่างถาวร
รูปที่ 2 การเชื่อมโยงระบบถาวรกับบริการโต้ตอบด้วยเสียง

หากตรวจสอบสถานะกระบวนการ (เช่น ใช้ dumpsys activity processes) คุณอาจเห็นกระบวนการอย่าง com.google.android.googlequicksearchbox:interactor ในสถานะ BFGS (บริการที่ทำงานอยู่เบื้องหน้าซึ่งเชื่อมโยงไว้) ซึ่งยังคงทำงานอยู่เนื่องจากการเชื่อมโยงจาก system_server (UID 1000)

NotificationListenerService

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

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

"หน้าจอ -1" ของ Launcher (ฟีดข่าว)

โดยทั่วไปแล้ว แอป Launcher สมัยใหม่จะรวมฟังก์ชันการนำทางหลัก (ไอคอนหน้าแรกและวิดเจ็ต) เข้ากับฟีดข่าวที่พร้อมใช้งานในหน้าจอ Launcher หน้าใดหน้าหนึ่ง และผสานรวมกับ UX ของ Launcher ได้อย่างราบรื่น ฟีดข่าวอาจมาจากแอปอื่น เช่น Launcher ใน Google Pixel จะผสานรวมกับฟีดที่มาจากแอป Google

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

ตัวอย่างอื่นๆ ที่พบบ่อย

  • Launcher (HOME_APP_ADJ): แอป Launcher (Home) มีช่องพิเศษของตัวเองในรายการลำดับความสำคัญ แม้ว่าจะไม่ได้เชื่อมโยงกับบริการเสมอไป แต่จะมีการกำหนด HOME_APP_ADJ (โดยปกติคือ 600) ระบบต้องการให้ Launcher ทำงานอยู่เสมอ เนื่องจากผู้ใช้กลับมาใช้งานบ่อยครั้ง อันที่จริงแล้ว ระบบจะเลือกปิดแอปที่ใช้ก่อนหน้านี้ (PREV_APP_ADJ = 700) มากกว่าปิด Launcher เนื่องจากจะทำให้ผู้ใช้ได้รับประสบการณ์การใช้งานที่ล่าช้าเมื่อออกจากแอปใดๆ เพราะผู้ใช้จะต้องรอให้ Launcher เริ่มทำงานใหม่ทั้งหมด
  • ตัวแก้ไขวิธีการป้อนข้อมูล (IME): เมื่อคุณพิมพ์ ระบบจะเชื่อมโยงกับแอปแป้นพิมพ์ที่คุณเลือก (เช่น Gboard) ซึ่งจะทำให้กระบวนการของแป้นพิมพ์อยู่ในสถานะที่ยกระดับแม้ว่าแป้นพิมพ์จะซ่อนอยู่ชั่วคราวก็ตาม ซึ่งจะช่วยให้แป้นพิมพ์ปรากฏขึ้นอีกครั้งทันทีเมื่อคุณแตะช่องข้อความอื่น
  • การชำระเงินผ่าน NFC: เมื่อคุณแตะโทรศัพท์เพื่อชำระเงิน ระบบจะเชื่อมโยงกับบริการชำระเงินผ่าน NFC (เช่น Google Wallet) ธุรกรรมเหล่านี้มักมีข้อกำหนดแบบเรียลไทม์ที่เข้มงวดจากเทอร์มินัลของผู้ขาย หากแอปการชำระเงินต้องเริ่มระบบใหม่ ธุรกรรมอาจหมดเวลาและดำเนินการไม่สำเร็จ

ข้อดีข้อเสียและประสิทธิภาพที่ลดลงอย่างรวดเร็ว

แม้ว่าการเชื่อมโยงจะจำเป็นต่อประสิทธิภาพและความถูกต้อง แต่ก็ส่งผลต่อประสิทธิภาพของหน่วยความจำของระบบ

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

แอนติแพทเทิร์นการผูกบริการที่พบบ่อย

เนื่องจากการผูกบริการจะยกระดับ oom_score_adj โดยตรง ข้อผิดพลาดเล็กน้อยเกี่ยวกับวงจรในการรับหรือจัดโครงสร้างการผูกอาจทำให้หน่วยความจำจำนวนมากถูกตรึงไว้ในสถานะที่มีสิทธิ์ (BTOP, BFGS หรือ PERC) เป็นเวลาหลายชั่วโมง โปรดระวังรูปแบบต่อต้านที่พบบ่อยเหล่านี้เมื่อออกแบบหรือตรวจสอบบริการที่มีผลผูกพัน

ลืม unbindService() ในไคลเอ็นต์ที่ใช้งานมานาน

การเชื่อมโยงกับบริการจากซิงเกิลตัน Application, ตัวจัดการเบื้องหลัง หรือ Activity ที่เรียก bindService ใน onStart โดยไม่มี unbindService ที่ตรงกันใน onStop จะทำให้ ServiceConnection รั่วไหล

ตราบใดที่การเชื่อมโยงนั้นยังคงทำงานอยู่ กระบวนการเป้าหมายจะรับค่าลำดับความสำคัญที่ยกระดับของไคลเอ็นต์มาใช้ หากไคลเอ็นต์เป็นคอมโพเนนต์ของระบบแบบถาวรหรือแอปที่ทำงานอยู่เบื้องหน้า กระบวนการของบริการที่มีผลผูกพันจะยังคงปักหมุดอยู่ใน BFGS หรือ BTOP อย่างไม่มีกำหนด (แสดงขึ้นเกือบ 100% ใน procstats) ซึ่งจะป้องกันไม่ให้ LMK เรียกคืนหน่วยความจำแม้ว่าบริการจะไม่มีการใช้งานเลยก็ตาม

วิธีแก้ไข: กำหนดขอบเขตการเชื่อมโยงให้สอดคล้องกับวงจรของคอมโพเนนต์ที่ต้องการอย่างเคร่งครัด หรือใช้การหมดเวลาเมื่อไม่มีการใช้งานซึ่งจะเรียกใช้ unbindService() หลังจากไม่มีการใช้งานเป็นระยะเวลาหนึ่ง หลีกเลี่ยงการเลิกเชื่อมโยงและเชื่อมโยงใหม่ในการเรียก RPC แต่ละครั้ง ซึ่งจะทำให้เกิดการทำงานที่ไม่มีประสิทธิภาพและค่าใช้จ่ายเพิ่มเติมในการตั้งค่า Binder ซ้ำๆ ให้รวมการทำงานที่เกิดขึ้นอย่างรวดเร็วไว้หลังตัวจับเวลาที่ไม่มีการใช้งานสั้นๆ (เช่น 5 ถึง 30 วินาที) แทน

การจัดวางบริการที่มีผลผูกพันร่วมกับ UI ที่ใช้หน่วยความจำมาก

โดยค่าเริ่มต้น คอมโพเนนต์ทั้งหมดใน APK จะทำงานในกระบวนการเดียวกัน หากแอปของคุณแสดงบริการที่มีผลผูกพันแบบ Lightweight (เช่น NotificationListenerService, ผู้ให้บริการวิดเจ็ต หรือบริการปลั๊กอินที่ระบบหรือ Launcher ผูกไว้) ในกระบวนการเดียวกับ Activity หลัก กระบวนการทั้งหมดจะรับสถานะที่ยกระดับของบริการ (BFGS หรือ PERC โดยปกติแล้ว oom_score_adj จะอยู่ที่ 200 หรือต่ำกว่า)

เมื่อผู้ใช้เปิด UI ของแอป กระบวนการจะจัดสรรลำดับชั้นการแสดงผลขนาดใหญ่ บิตแมปที่ถอดรหัสแล้ว และบัฟเฟอร์กราฟิก เมื่อผู้ใช้ออกจากหน้าจอ กระบวนการจะไม่ลดลงเหลือ CACHED (oom_score_adj จาก 900 ขึ้นไป) เนื่องจาก การผูกบริการ ที่ทำงานอยู่จะทำให้กระบวนการยังคงมีลำดับความสำคัญสูง ซึ่งทำให้เกิดปัญหา 2 อย่างที่ทับซ้อนกัน

  • ไม่มีการบีบอัดหน่วยความจำในเบื้องหลัง: CachedAppOptimizer ของระบบจะบีบอัดกระบวนการหลังจากเข้าสู่สถานะ CACHED เท่านั้น
  • ไม่มีการตัดแต่งหน่วยความจำ UI-hidden หรือ cached-LRU: เมื่อการผูกบริการคงกระบวนการไว้ใน BFGS หรือ PERC ระบบจะไม่ส่ง Callback การตัดแต่ง TRIM_MEMORY_UI_HIDDEN หรือ cached-LRU เช่น TRIM_MEMORY_BACKGROUND หากแอปไม่ปล่อยทรัพยากร UI เมื่อ UI ของแอปหยุดแสดง การจัดสรร UI สูงสุดจะยังคงปักหมุดอยู่ใน RAM ที่คะแนน OOM พิเศษซึ่ง LMK ไม่สามารถเรียกคืนได้

วิธีแก้ไข: นำแคช UI, บิตแมปที่ถอดรหัสแล้ว และข้อมูลอ้างอิงมุมมองออกเมื่อ UI ไม่แสดงอีกต่อไปโดยใช้ Activity.onStop, Application.ActivityLifecycleCallbacks หรือ ProcessLifecycleOwner หรือย้ายบริการที่มีผลผูกพันเสมอไปยังกระบวนการที่แยกต่างหากและมีขนาดเล็กโดยใช้แอตทริบิวต์ไฟล์ Manifest android:process เพื่อให้ระบบย้ายกระบวนการ UI หลักไปยังสถานะ CACHED เพื่อบีบอัดหรือเรียกคืนหน่วยความจำได้อย่างอิสระ

การละเว้นการแจ้งปัญหาที่ยกเว้นลำดับความสำคัญ

การเรียก bindService() ด้วย BIND_AUTO_CREATE เพียงอย่างเดียวจะโอนการจัดกำหนดการและลำดับความสำคัญของหน่วยความจำทั้งหมดของผู้เรียกไปยังบริการเป้าหมาย เมื่อแอปที่ทำงานอยู่เบื้องหน้าเชื่อมโยงกับบริการวิเคราะห์ การบันทึก หรือการดึงข้อมูลล่วงหน้าที่ทำงานอยู่เบื้องหลังโดยใช้เพียง BIND_AUTO_CREATE จะเป็นการส่งเสริมให้ผู้ปฏิบัติงานที่ทำงานอยู่เบื้องหลังนั้นเป็น BTOP โดยไม่ตั้งใจ

วิธีแก้ไข: เมื่อเชื่อมโยงกับบริการเสริมหรือบริการที่พยายามอย่างเต็มที่ซึ่งไม่จำเป็นต้องมีระดับการป้องกันเดียวกันกับ UI เบื้องหน้า ให้รวม BIND_AUTO_CREATE เข้ากับ BIND_WAIVE_PRIORITY, BIND_NOT_FOREGROUND หรือ BIND_NOT_PERCEPTIBLE เพื่อให้ระบบยังคงจัดการกระบวนการเป้าหมายในรายการ LRU ที่แคชไว้ได้


← ท้องถิ่น | ↑ ขึ้น | ทั้งระบบ →