งานเชน

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

หากต้องการสร้างห่วงโซ่งาน คุณสามารถใช้ WorkManager.beginWith(OneTimeWorkRequest) หรือ WorkManager.beginWith(List<OneTimeWorkRequest>) ซึ่งแต่ละโดเมนจะแสดงผลอินสแตนซ์ของ WorkContinuation

จากนั้นจะใช้ WorkContinuation เพื่อเพิ่ม OneTimeWorkRequest ที่เกี่ยวข้องได้ อินสแตนซ์ที่ใช้ then(OneTimeWorkRequest) หรือ then(List<OneTimeWorkRequest>) ที่ใช้เวลาเพียง 2 นาที

การเรียกใช้ WorkContinuation.then(...) ทุกครั้งจะแสดงผลอินสแตนซ์ ใหม่ ของ WorkContinuation หากคุณเพิ่มอินสแตนซ์ List จาก OneTimeWorkRequest รายการ คำขอเหล่านี้อาจทำงานพร้อมกันได้

สุดท้าย คุณสามารถใช้ WorkContinuation.enqueue() ไปยังenqueue()เชน WorkContinuation ของคุณได้

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

Kotlin

WorkManager.getInstance(myContext)
   // Candidates to run in parallel
   .beginWith(listOf(plantName1, plantName2, plantName3))
   // Dependent work (only runs after all previous work in chain)
   .then(cache)
   .then(upload)
   // Call enqueue to kick things off
   .enqueue()

Java

WorkManager.getInstance(myContext)
   // Candidates to run in parallel
   .beginWith(Arrays.asList(plantName1, plantName2, plantName3))
   // Dependent work (only runs after all previous work in chain)
   .then(cache)
   .then(upload)
   // Call enqueue to kick things off
   .enqueue();

อินพุตการผสาน

เมื่อคุณทำเชน OneTimeWorkRequest อินสแตนซ์ เอาต์พุตของงานระดับบนสุด ส่งเป็นอินพุตไปยังผู้เผยแพร่โฆษณาย่อย ดังนั้นในตัวอย่างข้างต้น ระบบจะส่งเอาต์พุตของ plantName1, plantName2 และ plantName3 ในรูปแบบ ข้อมูลที่ป้อนในคำขอ cache

WorkManager จะใช้เพื่อจัดการอินพุตจากคำของานระดับบนสุดหลายรายการ InputMerger

InputMerger ที่ WorkManager มีให้มีอยู่ 2 ประเภท ได้แก่

  • OverwritingInputMerger พยายามเพิ่มคีย์ทั้งหมดจากอินพุตทั้งหมดไปยังเอาต์พุต ในกรณีที่เกิดความขัดแย้ง จะเป็นการเขียนทับคีย์ที่ตั้งค่าไว้ก่อนหน้านี้

  • ArrayCreatingInputMerger พยายามผสานอินพุตและการสร้างอาร์เรย์เมื่อจำเป็น

หากคุณมีกรณีการใช้งานที่เจาะจงมากขึ้น ก็สามารถเขียนขึ้นเองโดยการแยกคลาสย่อย InputMerger

การเขียนทับInputMerger

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

เช่น หากพืชอินพุตแต่ละรายการมีคีย์ตรงกับอินพุตของพืชนั้นๆ ชื่อตัวแปร ("plantName1", "plantName2" และ "plantName3") จากนั้น ข้อมูลที่ส่งไปยังผู้ปฏิบัติงาน cache จะมีคู่คีย์-ค่า 3 คู่

แผนภาพแสดงงาน 3 งานที่ส่งเอาต์พุตที่แตกต่างกันไปยังงานถัดไปในเชน เนื่องจากเอาต์พุตทั้ง 3 รายการมีคีย์ต่างกัน งานถัดไปจึงได้รับคู่คีย์/ค่า 3 คู่

หากมีข้อขัดแย้ง ให้พนักงานคนสุดท้ายที่ "สำเร็จ" และคุณค่าของงานที่ทำสำเร็จ จะส่งไปยัง cache

แผนภาพแสดงงาน 3 งานที่ส่งผ่านเอาต์พุตไปยังงานถัดไปในเชน ในกรณีนี้ งาน 2 งานจากทั้ง 2 งานจะสร้างเอาต์พุตด้วยคีย์เดียวกัน ดังนั้นงานถัดไปจึงได้รับคู่คีย์/ค่า 2 คู่ โดยเอาต์พุตที่ขัดแย้งกันรายการใดรายการหนึ่งถูกตัด

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

การผสานอินพุตของอาร์เรย์ที่สร้าง

จากตัวอย่างข้างต้น เราต้องการรักษาผลผลิตที่ได้จากพืชทุกชนิด ชื่อผู้ปฏิบัติงาน เราควรใช้ ArrayCreatingInputMerger

Kotlin

val cache: OneTimeWorkRequest = OneTimeWorkRequestBuilderP<lantWorker(>)
   .setInputMerger(ArrayCreatingInputMerger::class)
   .setConstraints(constraints)
   .build()

Java

OneTimeWorkRequest cache = new OneTimeWorkRequest.Builder(PlantWorker.class)
       .setInputMerger(ArrayCreatingInputMerger.class)
       .setConstraints(constraints)
       .build();

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

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

หากมีความขัดแย้งของคีย์ ระบบจะจัดกลุ่มค่าที่เกี่ยวข้อง ไว้ด้วยกันในอาร์เรย์

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

สถานะงานและเชน

เชนของ OneTimeWorkRequest จะทำงานตามลำดับตราบเท่าที่มีงานดังกล่าว เสร็จสมบูรณ์ (กล่าวคือ แสดง Result.success()) ที่ทำงาน คำขออาจล้มเหลวหรือถูกยกเลิกในขณะที่เรียกใช้ ซึ่งส่งผลต่อดาวน์สตรีม คำขอการทำงานที่ขึ้นต่อกัน

เมื่อ OneTimeWorkRequest แรกอยู่ในคิวของคำของาน คำของานลำดับต่อมาทั้งหมดจะถูกบล็อกจนกว่างานชิ้นแรกจะเสร็จสิ้น เสร็จสมบูรณ์แล้ว

แผนภาพแสดงสายงาน งานแรกจัดคิวแล้ว งานต่อเนื่องทั้งหมดจะถูกบล็อกจนกว่างานแรกจะเสร็จสิ้น

เมื่ออยู่ในคิวและเป็นไปตามข้อจำกัดทั้งหมดของงานแล้ว คำของานแรก เริ่มทำงาน หากงานเสร็จสมบูรณ์ในรูท OneTimeWorkRequest หรือ List<OneTimeWorkRequest> (กล่าวคือ แสดงค่า Result.success()) คำของานที่อ้างอิงชุดถัดไปจะเป็น อยู่ในคิวแล้ว

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

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

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

แผนภาพแสดงสายงาน งานหนึ่งล้มเหลว แต่มีการกำหนดนโยบาย Backoff ระบบจะเรียกใช้งานนั้นอีกครั้งหลังจากผ่านระยะเวลาที่เหมาะสมไปแล้ว งานหลังจากงานในเชนจะถูกบล็อกจนกว่าจะทำงานสำเร็จ

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

หากนโยบายการลองใหม่นั้นไม่มีการกำหนดหรือหมดแล้ว หรือคุณไปถึง ซึ่ง OneTimeWorkRequest แสดงผล Result.failure() คำของานและคำของานที่เกี่ยวข้องทั้งหมดจะมีการทำเครื่องหมายเป็น FAILED.

แผนภาพแสดงสายงาน งาน 1 รายการล้มเหลวและลองใหม่ไม่ได้ ด้วยเหตุนี้ งานทั้งหมดหลังจากงานในเชนจึงล้มเหลวเช่นกัน

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

แผนภาพแสดงสายงาน ยกเลิกงาน 1 งานแล้ว ด้วยเหตุนี้ งานทั้งหมดหลังจากงานในเชนจึงถูกยกเลิกด้วย

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

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

สำหรับข้อมูลเพิ่มเติม โปรดดูการยกเลิกและการหยุด ที่ทำงาน