[25] GCD Flashcards by Roger Navarro Claros

What is a task? GCD

In Swift, this is usually a closure (a block of code).

How well did you know this?

Not at all

Perfectly

What is queue? GCD

A queue is an ordered list of tasks.

Tasks are submitted as closures to the queue in a first-in, first-out (FIFO) order

How well did you know this?

Not at all

Perfectly

What is GCD? GCD

Grand Central Dispatch: a low-level C API to schedule work on queues and utilize multicore concurrency.

How well did you know this?

Not at all

Perfectly

what is a thread? GCD

Is the system-level execution context (in the CPU) where a task runs.

How well did you know this?

Not at all

Perfectly

Main vs global queues? GCD

Main queue = main thread (UI). Global queues = background concurrent (non-UI).

How well did you know this?

Not at all

Perfectly

Difference between Queue and Thread in GCD

Queue → an ordered list of tasks (FIFO).
Thread → a system resource (execution context on the CPU).
GCD takes tasks from a queue and assigns them to threads as needed.

As a developer, you say “run this on queue Y,” and GCD decides the thread.

How well did you know this?

Not at all

Perfectly

How to dispatch work to the main queue? GCD

DispatchQueue.main.async { /* UI updates */ }

How well did you know this?

Not at all

Perfectly

sync vs async on a queue? GCD

sync blocks caller until finished; async returns to caller immediately.

How well did you know this?

Not at all

Perfectly

Serial vs concurrent queue? GCD

Serial runs one task at a time (only on thread is assigned)
Concurrent runs multiple threads (as much as the system has resources for) simultaneously.

How well did you know this?

Not at all

Perfectly

Create a serial queue GCD

let q = DispatchQueue(label: "com.acme.serial")

q.async {
    // runs off the caller thread, tasks execute one-by-one
    let result = heavyWork()
    DispatchQueue.main.async {
        updateUI(with: result)
    }
}

q.sync {
    // blocks the current thread until this finishes
    doSomething()
}

How well did you know this?

Not at all

Perfectly

Create a concurrent queue GCD

let q = DispatchQueue(label: "com.acme.concurrent", attributes: .concurrent)

How well did you know this?

Not at all

Perfectly

QoS purpose GCD

Hint to system about priority: .userInteractive, .userInitiated, .utility, .background.

How well did you know this?

Not at all

Perfectly

Set QoS on queue GCD

let q = DispatchQueue(label: "work", qos: .userInitiated)

How well did you know this?

Not at all

Perfectly

Why avoid heavy work on main? GCD

Blocks rendering/input → jank or ANRs (app not responding)

How well did you know this?

Not at all

Perfectly

What is a barrier block? GCD

If you have shared mutable state (e.g. a variable state), concurrent reads are fine, but concurrent writes (or read+write) can corrupt data.

Exclusive block on concurrent queue; acts like a write lock.

How well did you know this?

Not at all

Perfectly

Barrier example GCD

let q = DispatchQueue(label: "state", attributes: .concurrent)
q.async(flags: .barrier) { 
state = .ready 
}

How well did you know this?

Not at all

Perfectly

Delay work with GCD GCD

DispatchQueue.main.asyncAfter(deadline: .now()+0.3) {
... 
}

How well did you know this?

Not at all

Perfectly

What is DispatchGroup? GCD

Study These Flashcards

Group async tasks; get notified when all complete.

DispatchGroup example GCD

Study These Flashcards

let group = DispatchGroup()
for url in urls { 
    group.enter()
    fetch(url) { _ in
        g.leave()
    }
}
g.notify(queue: .main){ 
    done()
}

What is wait in a DispatchGroup?

Study These Flashcards

A synchronous method that will block the current queue until all the jobs have finished.

let group = DispatchGroup()

someQueue.async(group: group) { ... }
someQueue.async(group: group) { ... }
someOtherQueue.async(group: group) { ... }

if group.wait(timeout: .now() + 60) == .timedOut {
  print("The jobs didn’t finish in 60 seconds")
}

Note: Remember, this blocks the current thread; never ever call wait on the main queue.

Code the following: GCD
- serial queue
- async queue
- main queue
- global

Study These Flashcards

Serial: (you create)

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

Concurrent: (you create)

let concurrentQ = DispatchQueue(label: "com.example.concurrent", attributes: .concurrent)

Main: (system-provided)(not concurrent)

let mainQ = DispatchQueue.main

Global: (system-provided) (concurrent)

let globaQ = DispatchQueue.global(qos: .userInitiated)

What is DispatchSemaphore? GCD

Study These Flashcards

Counting semaphore to limit concurrency. (If you wish to enable four network downloads at once, then you pass in 4)

bridge callbacks (use sparingly).

Semaphore limit example GCD

Study These Flashcards

let sem = DispatchSemaphore(value: 3)
for job in jobs {
  DispatchQueue.global().async {
    sem.wait()
    doWork(job)
    sem.signal()
  } 
}

Self-deadlock pattern GCD

Study These Flashcards

Calling sync on the same serial queue you’re on.

Deadlock code smell `GCD`

```swift let q = DispatchQueue(label: "s") q.async { q.sync { print("deadlock") } } ```

Why DispatchWorkItem? `GCD`

DispatchWorkItem is a class that provides an actual object to hold the code you wish to submit to a queue. ``` let queue = DispatchQueue(label: "xyz") queue.async { print("The block of code ran!") } ``` Cancellation before start, custom QoS/flags, notify chaining.

Work item cancel `GCD`

``` let item = DispatchWorkItem { heavy() } q.async(execute: item) item.cancel() ```

Detect current queue? `GCD`

Use queue-specific keys or rely on actor/task context; don’t branch on labels.

Thread explosion cause `GCD`

Unbounded concurrency (too many global asyncs).

OperationQueue vs GCD `GCD`

OperationQueue = higher-level (deps, cancel); built on GCD.

Which should you choose? `GCD` or Operations?

if you’re just working with methods or chunks of code that need to be executed, GCD is a fitting choice. If you’re working with objects that need to encapsulate data and functionality then you’re more likely to utilize Operations.

Targeting queues `GCD`

```swift serial.setTarget(queue: DispatchQueue.global(qos: .background)) ```

Common DispatchSource? `GCD`

Timers, file descriptors, signals, process.

DispatchSourceTimer sample `GCD`

```swift let t = DispatchSource.makeTimerSource(queue: .main) t.schedule(deadline: .now(), repeating: 1) t.setEventHandler { tick() } t.resume() ```

Atomic updates via GCD `GCD`

Use a serial queue or concurrent + barrier around shared mutable state.

Why not spinlocks? `GCD`

Waste CPU/energy; prefer queues, os_unfair_lock, or actors.

Priority inversion handling `GCD`

GCD inherits/boosts QoS; keep critical sections short and QoS correct.

Debounce with GCD `GCD`

``` final class Debouncer { private let q = DispatchQueue(label: "deb"); private var work: DispatchWorkItem? func call(after d: TimeInterval, _ block:@escaping()->Void){ work?.cancel(); let w = DispatchWorkItem(block:block); work = w q.asyncAfter(deadline:.now()+d, execute:w) } } ```

Thread-safe dict pattern `GCD`

```swift final class SafeDict{ private var box:[K:V]=[:]; private let q=DispatchQueue(label:"rw", attributes:.concurrent) subscript(k:K)->V?{ get{ q.sync{box[k]} } set{ q.async(flags:.barrier){ self.box[k]=newValue } } } } ```

Background work after app bg `GCD`

Prefer BGTaskScheduler, background URLSession; avoid long main-queue work.

When pick GCD over async/await? `GCD`

Legacy interop, DispatchSource, precise queue control, OperationQueue integration.

what are the most common issues of GCD?

- Priority Inversion - Race conditions - Dead Lock

When I write this, what kind of queue I'm creating? `GCD` ``` private let q = DispatchQueue(label: "deb"); ```

By default, `DispatchQueue(label:)` creates a serial queue. Serial means only one task runs at a time, in the order you enqueue them. If you want a concurrent queue, you’d need to explicitly pass the attribute .concurrent: ``` let q = DispatchQueue(label: "deb", attributes: .concurrent) ```

[25] GCD Flashcards

(43 cards)