Dsync swift code#
Dsync swift free#

In a real restaurant, all of these tasks would be dispatched async and the restaurant would never deadlock. The real question is whether any of these three tasks should really be sync. Making any of the three steps async would fix this deadlock. Or the waiter could even ask for clarification asynchronously. Or the chef could prepare the meal asynchronously. The waiter could dispatch the order synchronously. Resolving the deadlock, in this case, is simple. Especially if you use sync a lot (which you generally shouldn't due to its blocking nature).

Dsync swift code#

However, in practice, you'll find that it's much harder to unravel and untangle your code and figure out how a deadlock occurs. In this case, both queues and all sync calls are close to each other so debugging isn't terrible. The waiter and chef queues are waiting for each other to finish which means that neither of them will finish. The waiter will never ask for clarification because the chef's sync work never finishes. The code here is somewhat more complicated than what you saw before but the effect is the same. Print('Chef: sure thing! Please ask the customer what soup they wanted.') Print('Waiter: hi chef, please make me 1 soup.') Can we write code that models this? Of course we can! let waiter = DispatchQueue(label: 'waiter') However, in the analogy, we were dealing with two 'queues' (the waiter and the chef). This is exactly what the code above does, and the situation is almost identical to the one described in the restaurant analogy earlier. Or as the official documentation for DispatchQueue.sync states:Ĭalling this function and targeting the current queue results in deadlock. The first closure can't complete until the second closure is run since its dispatched synchronously. The second closure can't run until the first one completes.

Putting this code anywhere in your app will immediately result in a crash before the second print statement runs. For example: let queue = DispatchQueue(label: 'my-queue') One way to deadlock a program in Swift is to dispatch synchronously to the current thread. However, if you're dispatching synchronously in your code regularly, odds are that your program might end up in a deadlock. Luckily, restaurants are asynchronous in how they are usually set up so a situation like this should never occur. Without the information, the chef cannot complete the soup. So the waiter will not do anything until the order is fulfilled.Īt the same time, the chef needs information from the waiter to continue so the chef dispatches a question to the waiter synchronously.Īnd since the chef did not yet fulfill the order, the waiter can not go and ask the customer for the type of soup they wanted. The waiter dispatched an order to the chef synchronously. No more meals will be prepared, no orders will be taken, no meals will be served. This means that the chef won't continue to work on any other meals until the waiter returns and tells the chef what soup should be served.Īnd the waiter replies: 'Sure, I'll ask after you serve the soup'. The chef dispatches this synchronously to the waiter. So the chef asks the waiter to go back to the customer and ask them for the type of soup they wanted. Now imagine that our waiter dispatched an order for a soup synchronously but they forgot to note down what kind of soup the customer wanted. If one of the restaurant's customers wants to order a drink the waiter will not take this order until the chef has prepared the meal that the waiter asked for. Remember how I explained that if a waiter dispatches orders to the kitchen synchronously the waiter would have to wait and do nothing while the chef prepares a meal and hands it to the waiter? This means that any tasks that are delegated to the waiter must occur after the chef has prepped the meal.

Let's continue this analogy to explain deadlocks more clearly. In my previous article I explained dispatching code on a dispatch queue using a restaurant analogy. So more broadly speaking you're code is waiting for something to happen before it runs, but that something will never happen. It could be a database handle, a file on the filesystem, or even time to run code on the CPU. You can think of this resource as almost anything.

Dsync swift free#

In short, a deadlock can occur when the system is waiting for a resource to free up while it's logically impossible for that resource to become available. It'll make following this week's article much easier. If you're not familiar with DispatchQueue.sync and DispatchQueue.async I would recommend that you read the article I linked in the previous paragraph before continuing. Instead of making that post longer and more complicated, I decided to make this week's post all about deadlocks and understanding what they are. Several people pointed out that that post does not mention deadlocks. A few weeks ago, I wrote about dispatching code synchronously and asyncronously.