13 — Target Queues

🍽️ Intuition

Several small intake counters, each with its own line, all ultimately funnel into the same pass — the shared handoff point where every order gets serialized before it reaches the chefs. Even though each counter has its own line, orders from every counter still pass through that one shared point.

🧠 What It Means In Swift

A DispatchQueue can target another queue via its target: parameter. Work submitted to the first queue doesn't actually run in its own context — it executes on the target queue's context instead. This lets you funnel multiple independent queues through one shared serial queue for coordinated serialization, or route work onto a specific QoS-tier global queue without creating a new thread pool.

📊 ASCII Diagram

 sub1 ──┐
        ├──▶ [ shared serial queue = the pass ] ──▶ chefs
 sub2 ──┘

💻 Tiny Swift Example

let shared = DispatchQueue(label: "shared-serial")
let sub1 = DispatchQueue(label: "sub1", target: shared)
let sub2 = DispatchQueue(label: "sub2", target: shared)

sub1.async { print("From sub1, serialized through shared") }
sub2.async { print("From sub2, serialized through shared") }

👉 Even though sub1 and sub2 are separate queue objects, work submitted to either one is serialized through shared — no two blocks from sub1 and sub2 ever run at the same time.

🔄 vs. Swift Concurrency

There's no direct equivalent — actor executors can be customized, but that's a different mechanism aimed at controlling where an actor runs, not at funneling multiple independent queues into one shared serialization point.

🧸 Memory Sentence

Target queues let many order lines funnel through one shared pass.

⚠️ Analogy Limit

Unlike a physical pass, target queue chains can be arbitrarily deep — a queue can target a queue that targets another queue. That flexibility can make debugging execution order harder than the analogy suggests.

✅ Check Your Understanding

What happens to two independent serial queues if they both target the same serial queue?