GCD Main Thread Crash Issue (Explanation Needed)?

Question

why do this piece of code causes crash ?

 DispatchQueue.main.sync {
        // Operation To Perform 
 }

why we have to write this way :-

DispatchQueue.global().async(execute: {
    print("test")
    DispatchQueue.main.sync{
        print("main thread")
    }
})

and when we write code in CellForRowAt or any other method in which thread it goes main or global on how it works sync or async way ?

Possible duplicate of [What does main.sync in global().async mean?](https://stackoverflow.com/questions/42772907/what-does-main-sync-in-global-async-mean) — Prashant Tukadiya, Feb 06 '18 at 09:12
Why crash In Short **calling sync and targeting current queue is a deadlock (calling queue waits for the sync block to finish, but it does not start because target queue (same) is busy waiting for the sync call to finish) and thats probably why the crash.** — Prashant Tukadiya, Feb 06 '18 at 09:14
For Second block : **You are creating global queue and then you are getting main queue so now there is no dead lock** — Prashant Tukadiya, Feb 06 '18 at 09:17
Possible duplicate of [main.async vs main.sync() vs global().async in Swift3 GCD](https://stackoverflow.com/questions/46732016/main-async-vs-main-sync-vs-global-async-in-swift3-gcd) — Lal Krishna, Feb 06 '18 at 09:41

score 3 · Accepted Answer · answered Feb 06 '18 at 09:28

According to Apple, attempting to synchronously executing a work item on main queue results into a dead-lock.

So writing DispatchQueue.main.sync {} can lead to deadlock condition as all the UI operations performed by app is performed on main queue unless we manually switch some task on the background queue. This also answer your question regarding on which thread CellForRowAt is called. All the methods related to UI operation or UIkit are called from main thread

Performing a task synchronously means blocking a thread until the task is not completed and in this case you are attempting to block main thread on which the system / app would be already performing some task and that can lead to deadlock. Blocking main thread is not at all recommended and thats why we need to switch asynchronously to a background thread so that main thread is not blocked.

To read more you can visit the following link: https://developer.apple.com/documentation/dispatch

score 1 · Answer 2 · answered Feb 06 '18 at 09:26

Why crash In Short

DispatchQueue.main.sync {
    // Operation To Perform 
}

calling sync and targeting current queue is a deadlock (calling queue waits for the sync block to finish, but it does not start because target queue (same) is busy waiting for the sync call to finish) and thats probably why the crash.

For Second block : You are creating global queue and then you are getting main queue so now there is no dead lock

If you have ever used semaphore which has same issue if you don't take care it has two methods wait and signal with wait if you block main thread then your code will never executed.

hope it is helpful

score 0 · Answer 3 · answered Feb 06 '18 at 09:35

 DispatchQueue.main.sync {
     // Operation To Perform 
 }

Calling sync on a serial queue (like main) that you're already on will cause a deadlock. The first process can't finish because it's waiting for the second process to finish, which can't finish because it's waiting for the first to finish etc.

DispatchQueue.global().async(execute: {
    print("test")
    DispatchQueue.main.sync{
        print("main thread")
    }
})

Calling sync on the main thread from here works as you're moving the task to the global() queue.

There's a great 2 part GCD tutorial on raywenderlich.com which I encourage you to read https://www.raywenderlich.com/148513/grand-central-dispatch-tutorial-swift-3-part-1.

GCD Main Thread Crash Issue (Explanation Needed)?

3 Answers3