DispatchQueue中async的含义疑问：对比JavaScript中的async

Great question! It’s totally normal to get confused here—async means subtly different things in these two environments, and the behavior you saw in WWDC comes down to how Grand Central Dispatch (GCD) queues work. Let’s unpack this step by step.

First: What async means in JavaScript #

In JS, async is all about marking a function as returning a Promise, and letting the code run without blocking the single-threaded event loop. When you call an async function without await, it kicks off a task that runs in the background (in the event queue) while your main code keeps going.

The "unordered execution" you’re thinking of happens when async tasks have different completion times—like if you have async functions waiting on network calls or timers. For example:

console.log("Start");

async function fetchData1() {
  await new Promise(resolve => setTimeout(resolve, 200));
  console.log("Data 1 ready");
}

async function fetchData2() {
  await new Promise(resolve => setTimeout(resolve, 100));
  console.log("Data 2 ready");
}

fetchData1();
fetchData2();
console.log("End");

Here, Data 2 ready prints before Data 1 ready because its timer finishes faster—even though you called fetchData1() first. That’s the "unordered" behavior you’re familiar with.

Now: What async means in DispatchQueue (GCD) #

In GCD, async has a simpler definition: "Submit this task to the queue, but don’t block the current thread waiting for it to finish". The order in which tasks execute depends entirely on the type of queue you’re using:

1. Serial Queues (the WWDC example case) #

Serial queues (like the main queue, or a queue you create with DispatchQueue(label: "my.serial.queue")) only run one task at a time, in the exact order you submit them. So even if you use async, the tasks line up and execute sequentially.

Here’s a Swift example that matches what you saw in WWDC:

let serialQueue = DispatchQueue(label: "com.example.serial")

print("Start")
serialQueue.async {
    print("Task 1")
}
serialQueue.async {
    print("Task 2")
}
serialQueue.async {
    print("Task 3")
}
print("End")

Output:

Start
End
Task 1
Task 2
Task 3

The async just means the main thread doesn’t wait for the tasks to finish—it prints "End" right away. But the queue itself ensures tasks run in order, which makes them look "synchronous" in their execution relative to each other.

2. Concurrent Queues (the "unordered" case) #

If you use a concurrent queue (like the global queue DispatchQueue.global()), GCD will run multiple tasks at the same time on different threads. Here, async tasks can finish in any order, just like JS’s async behavior with varying completion times:

let concurrentQueue = DispatchQueue.global()

print("Start")
concurrentQueue.async {
    print("Task 1")
}
concurrentQueue.async {
    print("Task 2")
}
concurrentQueue.async {
    print("Task 3")
}
print("End")

Possible Output:

Start
End
Task 2
Task 1
Task 3

The order changes every time because the OS schedules the tasks on different threads, and whichever finishes first prints first.

The Core Difference #

• In JS, async is tied to Promise-based asynchronous code in a single-threaded event loop. "Unordered" execution comes from tasks taking different amounts of time to resolve.
• In GCD, async is about not blocking the current thread. The order of task execution is controlled by the queue type: serial queues enforce order, concurrent queues allow parallel, unordered execution.

The WWDC demo almost certainly used a serial queue (maybe the main queue, since it’s common for UI-related tasks), which is why the async tasks ran in order. If they’d used a concurrent queue, you’d have seen the unordered behavior you expected from JS.

内容的提问来源于stack exchange，提问作者Carpetfizz