What happens if dispatch on same queue?

问题

I'd like to understand for below case if it's needed to check whether callbackQueue is current queue.

Please help me clear these scenarios, about what could happen if current queue is callback queue:

callbackQueue is main queue.
callbackQueue is concurrent queue.
callbackQueue is serial queue.

- (void)fetchWithCallbackQueue:(dispatch_queue_t)callbackQueue
{
  dispatch_async(callbackQueue, ^{

  });
}

回答1:

I highly recommend you to watch these videos. Then go through the examples I provided and then change the code and play around with them as much as you can. It took me 3 years to feel fully comfortable with iOS multi-threading so take your time :D

Watch the first 3 minutes of this RWDevCon video and more if you like.

Also watch 3:45 until 6:15. Though I recommend you watch this video in its entirety.

To summarize the points the videos make in the duration I mentioned:

threading and conccurrency is all about the source queue and destination. queue.

sync vs. async is specifically a matter of the source queue.

Think of source and destination queues of a highway where your work is being done.

If you do async, then it's like you sending a car (has to deliver stuff) exiting the highway and then continue to let other cars drive in the highway.

If you do sync, then it's like you sending a car (has to deliver stuff) exiting the highway and then halting all other cars on the highway until the car delivers all its stuff.

Think of a car delivering stuff as a block of code, starting and finishing execution.

What happens for main queue is identical to what happens for serial queue. They're both serial queues.

So if you're already on main thread and dispatch to main thread and dispatch asynchronously then, anything you dispatch will go to the end of the queue

To show you what I mean: In what order do you think this would print? You can easily test this in Playground:

DispatchQueue.main.async {
    print("1")
    print("2")
    print("3")
    DispatchQueue.main.async {
        DispatchQueue.main.async {
            print("4")
        }
        print("5")
        print("6")
        print("7")
    }
    print("8")
}

DispatchQueue.main.async {
    print("9")
    print("10")
}

It will print:

Why?

It's mainly because every time you dispatch to main, it will go to the end of queue.

Dispatching to main while you're already on the main queue is very hidden subtle reason for many tiny delays that you see in an app's user-interaction.

What happens if you dispatch to the same serial queue using sync?

Deadlock! See here

If you dispatch to the same concurrent queue using sync, then you won't have a deadlock. But every other thread would just wait the moment you do sync. I've discussed that below.

Now if you're trying to dispatch to a concurrent queue, then if you do sync, it's just like the example of the highway, where the entire 5 lane highway is blocked till the car delivers everything. But it's kinda useless to do sync on a concurrent queue, unless you're doing something like a .barrier queue and are trying to solve a read-write problem.

But to just see what happens if you do sync on a concurrent queue:

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

for i in 0...4 {
    if i == 3 {
        queue.sync {
            someOperation(iteration: UInt32(i))
        }
    } else {
        queue.async {
            someOperation(iteration: UInt32(i))
        }
    }
}

func someOperation(iteration: UInt32) {
    sleep(1)
    print("iteration", iteration)
}

will log:

// '3' will ALWAYS be first, because it's chocking the entire queue. 
// The rest happen concurrently. And each time you run the app, the sequence of the rest would be different, because of the nature of concurrency. But likely 4 will be closer to being completed last and 0 would be closer to being finished sooner.

iteration 3     
iteration 0
iteration 2
iteration 1
iteration 4

If you do async on a concurrent queue, then assuming you have a limited number of concurrent threads, e.g. 5 then 5 tasks would get executed at once. Just that each given task is going to the end of the queue. It would make sense to do this for logging stuff. You can have multiple log threads. One thread logging location events, another logging purchases, etc.

A good playground example would be:

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

func delay(seconds: UInt32 ) {
    queue.async {
        sleep(seconds)
        print(seconds)
    }
}

for i in (1...5).reversed() {
    delay(seconds: UInt32(i))
}

Even though you've dispatched the 5 first, this would print

回答2:

In your example with dispatch_async (or just async in Swift), it doesn’t matter. The dispatched block will simply be added to the end of the relevant queue and will run asynchronously whenever that queue becomes available.

If, however, you used dispatch_sync (aka sync in Swift), then suddenly problems are introduced if you dispatch from a serial queue back to itself. With a “synchronous” dispatch from a serial queue to itself, the code will will “deadlock”. (And because the main queue is a serial queue, synchronous dispatches from main queue to itself manifest the same problem.) The dispatch_sync says “block the current thread until the designated queue finishes running this dispatched code”, so obviously if any serial queue dispatches synchronously back to itself, it cannot proceed because it’s blocking the queue to which you’ve dispatched the code to run.

Note that any blocking GCD API, such as dispatch_semaphore_wait and dispatch_group_wait (both known as simply wait in Swift), will suffer this same problem as the synchronous dispatch if you wait on the same thread that the serial queue uses.

But, in your case, dispatching asynchronously with dispatch_async, you shouldn’t have any problems.

来源：https://stackoverflow.com/questions/58600133/what-happens-if-dispatch-on-same-queue

标签

ios

grand-central-dispatch