ความแตกต่างระหว่าง dispatch_async และ dispatch_sync บน Serial Queue?

ฉันได้สร้างอนุกรมคิวดังนี้:

    dispatch_queue_t _serialQueue = dispatch_queue_create("com.example.name", DISPATCH_QUEUE_SERIAL);

อะไรคือความแตกต่างระหว่างที่dispatch_asyncเรียกเช่นนี้

 dispatch_async(_serialQueue, ^{ /* TASK 1 */ });
 dispatch_async(_serialQueue, ^{ /* TASK 2 */ });

แล้วdispatch_syncเรียกแบบนี้บนซีเรียลคิว?

 dispatch_sync(_serialQueue, ^{ /* TASK 1 */ });
 dispatch_sync(_serialQueue, ^{ /* TASK 2 */ });

ความเข้าใจของฉันคือไม่ว่าจะใช้วิธีการจัดส่งแบบใดTASK 1จะถูกดำเนินการและเสร็จสิ้นก่อนTASK 2ถูกต้องหรือไม่?

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

สำหรับรหัสนี้

dispatch_async(_serialQueue, ^{ printf("1"); });
printf("2");
dispatch_async(_serialQueue, ^{ printf("3"); });
printf("4");

มันอาจจะพิมพ์2413หรือ2143หรือ1234แต่1ก่อนเสมอ3

สำหรับรหัสนี้

dispatch_sync(_serialQueue, ^{ printf("1"); });
printf("2");
dispatch_sync(_serialQueue, ^{ printf("3"); });
printf("4");

มันมักจะพิมพ์ 1234

หมายเหตุ: สำหรับรหัสแรกก็จะไม่1324พิมพ์ เนื่องจากprintf("3")ถูกส่งไปหลังจาก printf("2")ดำเนินการแล้ว และงานสามารถดำเนินการได้หลังจากที่ส่งไปแล้วเท่านั้น

เวลาดำเนินการของงานไม่เปลี่ยนแปลงอะไร รหัสนี้จะพิมพ์เสมอ12

dispatch_async(_serialQueue, ^{ sleep(1000);printf("1"); });
dispatch_async(_serialQueue, ^{ printf("2"); });

สิ่งที่อาจเกิดขึ้นคือ

• เธรด 1: dispatch_async งานที่เสียเวลา (ภารกิจ 1) ไปยังคิวอนุกรม
• เธรด 2: เริ่มดำเนินการภารกิจ 1
• เธรด 1: dispatch_async งานอื่น (ภารกิจ 2) ไปยังคิวอนุกรม
• เธรด 2: ภารกิจ 1 เสร็จสิ้น เริ่มดำเนินการภารกิจ 2
• เธรด 2: ภารกิจ 2 เสร็จสิ้น

และคุณจะเห็นเสมอ 12

ความแตกต่างระหว่างdispatch_syncและdispatch_asyncเป็นเรื่องง่าย

ในทั้งสองตัวอย่างของคุณTASK 1จะดำเนินการก่อนเสมอTASK 2เนื่องจากถูกส่งไปก่อนหน้านั้น

อย่างไรก็ตามในdispatch_syncตัวอย่างนี้คุณจะไม่จัดส่งTASK 2จนกว่าจะTASK 1ถูกส่งและดำเนินการในภายหลัง นี้เรียกว่า"ปิดกั้น" รหัสของคุณจะรอ (หรือ "บล็อก") จนกว่างานจะดำเนินการ

ในdispatch_asyncตัวอย่างโค้ดของคุณจะไม่รอให้การดำเนินการเสร็จสมบูรณ์ บล็อกทั้งสองจะส่ง (และจัดคิว) ไปยังคิวและโค้ดที่เหลือของคุณจะดำเนินการต่อในเธรดนั้น จากนั้นในอนาคต (ขึ้นอยู่กับสิ่งที่ถูกส่งไปยังคิวของคุณ) Task 1จะดำเนินการจากนั้นจึงTask 2จะดำเนินการ

ทั้งหมดเกี่ยวข้องกับคิวหลัก มี 4 การเรียงสับเปลี่ยน

i) อนุกรมคิวส่ง async: ที่นี่งานจะดำเนินการทีละรายการ แต่เธรดหลัก (ผลต่อ UI) จะไม่รอการส่งคืน

ii) คิวอนุกรมการซิงค์การจัดส่ง: ที่นี่งานจะดำเนินการทีละรายการ แต่เธรดหลัก (ผลต่อ UI) จะแสดงความล่าช้า

iii) คิวพร้อมกันส่ง async: ที่นี่งานจะดำเนินการแบบคู่ขนานและเธรดหลัก (ผลต่อ UI) จะไม่รอการส่งคืนและจะราบรื่น

iv) คิวพร้อมกันการซิงค์การจัดส่ง: ที่นี่งานจะดำเนินการแบบขนาน แต่เธรดหลัก (ผลต่อ UI) จะแสดงความล่าช้า

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

และสุดท้ายนี้เป็นวิธีเจาะกลับไปที่เธรดหลักเมื่อเราทำธุรกิจของเราเสร็จแล้ว:

DispatchQueue.main.async {
     // Do something here
}