What is the most vivid example of a deadlock in iOS you can give?

The most vivid example of a deadlock in iOS occurs when attempting to update the UI from a background thread without using proper mechanisms.

// This code will cause a deadlock or crash (depending on iOS version and context)
// when called not from the main thread
DispatchQueue.global().async {
    // Perform some background work...
    print("Background work is being performed")

    // Attempt to update UI directly from a background thread
    // This will cause an exception or deadlock, as UIKit is not thread-safe
    DispatchQueue.main.sync {
        // Attempt to update a label on the main thread
        // But since we are already synchronously waiting for the main thread, which is blocked
        // by our own sync block, a deadlock occurs.
        print("Attempting to update UI")
        // someLabel.text = "Updated from background" // Example line that would cause the problem
    }
    print("Background work completed")
}

Explanation:

UIKit (the framework for building user interfaces in iOS) is not thread-safe. All UI operations must be performed strictly on the main thread.

In the example above, if you call the block DispatchQueue.main.sync { ... } from a background thread, then:

1. The background thread is blocked and waits for the main thread to execute the code sent to it.
2. The main thread may be busy or, more likely in this scenario, itself waiting for some operation to complete, which should have been started from the background thread (although this specific example does not include that).
3. With sync, the background thread cannot finish its work until the main thread executes the block. If the main thread is already blocked (for example, waiting for a background operation that in turn is waiting for the main thread, or simply busy), a cycle of waiting occurs, leading to a deadlock.

Correct solution:

Use asynchronous dispatch to the main thread for UI updates.

// Correct approach: update UI asynchronously on the main thread
DispatchQueue.global().async {
    // Perform some background work...
    print("Background work is being performed")

    // Send UI update asynchronously to the main thread
    DispatchQueue.main.async {
        print("Updating UI on the main thread")
        // someLabel.text = "Updated from background" // Proper place to update UI
    }
    print("Background work completed")
}

Here, the background thread is not blocked when dispatching the block to the main thread, allowing both the background task and the main thread to work independently, avoiding deadlocks.