dispatch_get_main_queue() doesn't run new async jobs smoothly

Question

let dispatchGroup = dispatch_group_create()
let now = DISPATCH_TIME_NOW

for i in 0..<1000 {
    dispatch_group_enter(dispatchGroup)

    // Do some async tasks
    let delay = dispatch_time(now, Int64(Double(i) * 0.1 * Double(NSEC_PER_SEC)))

    dispatch_after(delay, dispatch_get_main_queue(), {
        print(i)
        dispatch_group_leave(dispatchGroup)
    })
}

The print statement can print first 15-20 numbers smoothly, however, when i goes larger, the print statement prints stuff in a sluggish way. I had more complicated logic inside dispatch_after and I noticed the processing was very sluggish, that's why I wrote this test.

Is there a buffer size or other properties that I can configure? It seems dispatch_get_main_queue() doesn't work well with bigger number of async tasks.

Thanks in advance!

Answer 1

The problem isn't dispatch_get_main_queue(). (You'll notice the same behavior if you use a different queue.) The problem rests in dispatch_after().

When you use dispatch_after, it creates a dispatch timer with a leeway of 10% of the start/when. See the Apple github libdispatch source. The net effect is that when these timers (start ± 10% leeway) overlap, it may start coalescing them. When they're coalesced, they'll appear to fire in a "clumped" manner, a bunch of them firing immediately right after another and then a little delay before it gets to the next bunch.

There are a couple of solutions, all entailing the retirement of the series of dispatch_after calls:

1. You can build timers manually, forcing DispatchSource.TimerFlag.strict to disable coalescing:

    let group = DispatchGroup()
    let queue = DispatchQueue.main
   
    let start = CACurrentMediaTime()
   
    os_log("start")
   
    for i in 0 ..< 1000 {
        group.enter()
   
        let timer = DispatchSource.makeTimerSource(flags: .strict, queue: queue) // use `.strict` to avoid coalescing
        timer.setEventHandler {
            timer.cancel()       // reference timer so it has strong reference until the handler is called
            os_log("%d", i)
            group.leave()
        }
        timer.schedule(deadline: .now() + Double(i) * 0.1)
        timer.resume()
    }
   
    group.notify(queue: .main) {
        let elapsed = CACurrentMediaTime() - start
        os_log("all done %.1f", elapsed)
    }
   

   Personally, I dislike that reference to timer inside the closure, but you need to keep some strong reference to it until the timer fires, and GCD timers release the block (avoiding strong reference cycle) when the timer is canceled/finishes. This is inelegant solution, IMHO.

2. It is more efficient to just schedule single repeating timer that fires every 0.1 seconds:

    var timer: DispatchSourceTimer?    // note this is property to make sure we keep strong reference 
   
    func startTimer() {
        let queue = DispatchQueue.main
   
        let start = CACurrentMediaTime()
   
        var counter = 0
   
        // Do some async tasks
   
        timer = DispatchSource.makeTimerSource(flags: .strict, queue: queue)
        timer!.setEventHandler { [weak self] in
            guard counter < 1000 else {
                self?.timer?.cancel()
                self?.timer = nil
                let elapsed = CACurrentMediaTime() - start
                os_log("all done %.1f", elapsed)
                return
            }
            os_log("%d", counter)
            counter += 1
        }
        timer!.schedule(deadline: .now(), repeating: 0.05)
        timer!.resume()
    }
   

   This not only solves the coalescing problem, but it also is more efficient.

For Swift 2.3 rendition, see previous version of this answer.