Sự khác biệt giữa Clark_async và Clark_sync trên hàng đợi nối tiếp?

Tôi đã tạo một hàng đợi nối tiếp như thế này:

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

Sự khác biệt giữa dispatch_asyncđược gọi như thế này là gì

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

Và dispatch_syncđược gọi như thế này trên hàng đợi nối tiếp này?

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

Hiểu biết của tôi là, bất kể phương thức công văn nào được sử dụng, TASK 1sẽ được thực hiện và hoàn thành trước đó TASK 2, đúng không?

Đúng. Sử dụng hàng đợi nối tiếp đảm bảo thực hiện nối tiếp các nhiệm vụ. Sự khác biệt duy nhất là dispatch_syncchỉ trả về sau khi khối kết thúc trong khi dispatch_asynctrả về sau khi được thêm vào hàng đợi và có thể không kết thúc.

cho mã này

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

Nó có thể in 2413hoặc 2143hay 1234nhưng 1luôn luôn trước3

cho mã này

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

nó luôn luôn in 1234

Lưu ý: Đối với mã đầu tiên, nó sẽ không in 1324. Bởi vì printf("3")được gửi sau khi printf("2") được thực thi. Và một nhiệm vụ chỉ có thể được thực hiện sau khi nó được gửi đi.

Thời gian thực hiện của các nhiệm vụ không thay đổi bất cứ điều gì. Mã này luôn luôn in12

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

Những gì có thể xảy ra là

• Chủ đề 1: Clark_async một nhiệm vụ tốn thời gian (nhiệm vụ 1) cho hàng đợi nối tiếp
• Chủ đề 2: bắt đầu thực hiện nhiệm vụ 1
• Chủ đề 1: Clark_async một nhiệm vụ khác (nhiệm vụ 2) cho hàng đợi nối tiếp
• Chủ đề 2: nhiệm vụ 1 đã hoàn thành. bắt đầu thực hiện nhiệm vụ 2
• Chủ đề 2: nhiệm vụ 2 đã hoàn thành.

và bạn luôn thấy 12

Sự khác biệt giữa dispatch_syncvà dispatch_asynclà đơn giản.

Trong cả hai ví dụ của bạn, TASK 1sẽ luôn luôn thực thi trước TASK 2vì nó được gửi trước nó.

Trong dispatch_syncví dụ, tuy nhiên, bạn sẽ không gửi TASK 2cho đến khi TASK 1đã được gửi đi và được thực thi . Điều này được gọi là "chặn" . Mã của bạn chờ (hoặc "khối") cho đến khi tác vụ thực thi.

Trong dispatch_asyncví dụ này, mã của bạn sẽ không chờ thực thi hoàn tất. Cả hai khối sẽ gửi (và được xử lý) đến hàng đợi và phần còn lại của mã của bạn sẽ tiếp tục thực thi trên luồng đó. Sau đó, tại một thời điểm nào đó trong tương lai, (tùy thuộc vào những gì khác đã được gửi đến hàng đợi của bạn), Task 1sẽ thực thi và sau đó Task 2sẽ thực thi.

Tất cả đều liên quan đến hàng đợi chính. Có 4 hoán vị.

i) Hàng đợi nối tiếp, gửi async: Ở đây, các tác vụ sẽ thực hiện lần lượt từng cái, nhưng luồng chính (hiệu ứng trên UI) sẽ không chờ trả về

ii) Hàng đợi nối tiếp, đồng bộ hóa công văn: Ở đây các tác vụ sẽ thực hiện lần lượt từng cái, nhưng luồng chính (hiệu ứng trên UI) sẽ hiển thị độ trễ

iii) Hàng đợi đồng thời, gửi async: Tại đây, các tác vụ sẽ thực thi song song và luồng chính (hiệu ứng trên UI) sẽ không chờ trả về và sẽ trơn tru.

iv) Hàng đợi đồng thời, đồng bộ hóa công văn: Ở đây các tác vụ sẽ thực thi song song, nhưng luồng chính (hiệu ứng trên UI) sẽ hiển thị độ trễ

Sự lựa chọn của bạn về hàng đợi đồng thời hoặc nối tiếp phụ thuộc vào việc bạn có cần một đầu ra từ một nhiệm vụ trước cho nhiệm vụ tiếp theo hay không. Nếu bạn phụ thuộc vào tác vụ trước, hãy chấp nhận hàng đợi nối tiếp khác nhận hàng đợi đồng thời.

Và cuối cùng, đây là một cách thâm nhập trở lại chủ đề chính khi chúng tôi hoàn thành công việc của mình:

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