What are the consequences of calling the Sync method on a Concurrent queue in a multithreaded environment?

Calling the sync method (for example, dispatch_sync) on a concurrent queue in a multithreaded environment can lead to a deadlock if this call occurs from the same queue.

Why?

• dispatch_sync synchronously blocks the current thread, waiting for the passed task to complete.
• If you call dispatch_sync on the same queue where code is already executing, the task cannot start because the current thread is blocked, and the queue cannot switch to execute the new task.

For concurrent queues, this is less critical than for serial queues, as a concurrent queue can execute multiple tasks simultaneously. However, if dispatch_sync is called from a task already running on this concurrent queue, and the queue is limited in the number of threads, a deadlock can occur.

Summary:

• Calling dispatch_sync on a concurrent queue from another thread is usually safe.
• Calling dispatch_sync on the same queue where code is already executing can lead to a deadlock.

Example:

let queue = DispatchQueue(label: "concurrentQueue", attributes: .concurrent)

queue.async {
    print("Start")
    // Dangerous call if the queue is limited and blocks the current thread
    queue.sync {
        print("Inner sync")
    }
    print("End")
}

In this example, a deadlock may occur if the queue cannot execute the nested task until the current one finishes.