Dispatch Groups | Chinese Rule of Eight

Dispatch group demo xCode 8.3.3

DispatchQueue uses enter() and leave() to group chunks of code into one work item and process them in the group. This can be done async or sync.

Note that DispatchQueues do not use sync, because the purpose would not make sense. The whole purpose of a DispatchGroup is to have multiple tasks run, and notify when they are done. Since sync is done one by one, and in order, there is no purpose to notify anything due to the nature of sync: Each task must begin and end in order.

Source Code

import UIKit

class ViewController: UIViewController {

let globalQueue = DispatchQueue.global()

var button : UIButton? = nil

func action(selector:UIButton) {

print("Button Clicked")

}

override func viewDidLoad() {

print("--viewDidLoad--")

super.viewDidLoad()

self.button = UIButton(type: UIButtonType.roundedRect) as UIButton

self.button?.backgroundColor = UIColor.orange

self.button?.addTarget(self, action: #selector(action), for: UIControlEvents.touchUpInside)

self.button?.frame = CGRect(x: 80, y: 60, width: 200, height: 80)

self.button?.setTitle("Push Me", for: .normal)

print("button created")

self.view.addSubview(self.button!)

print("view hieararchy added button")

}

override func viewDidAppear(_ animated: Bool) {

super.viewDidAppear(animated)

let dispatchGroup = DispatchGroup()

for i in 0...3 {

// get another global queue, and so async operation

(DispatchQueue.global(qos: .userInitiated)).async(group: dispatchGroup, qos: .userInitiated, flags: .assignCurrentContext) {

() -> Void

dispatchGroup.enter()

// code below here have entered the dispatch group

print("----- code execution entered dispatchGroup for index \(i) ------")

print("code execution \(i) start")

for j in 0...100 {

Thread.sleep(forTimeInterval: 0.01 * TimeInterval(i))

print("\(j)----\(i)---")

}

print("code execution \(i) finish\n")

// code done. execution leaves

dispatchGroup.leave()

print("------ code execution left dispatchGroup for index \(i) --------")

}

// The code below is called when there are no more items

// left in the group. You also specify that you want to schedule the completion work to be run on the global queue. If you want it done on the main queue display use DispatchQueue.main

dispatchGroup.notify(queue: DispatchQueue.global(qos: .userInitiated)) {

() -> Void

print("\nBlock 4\n")

}

} // for

}

override func didReceiveMemoryWarning() {

super.didReceiveMemoryWarning()

// Dispose of any resources that can be recreated.

}

First, take note that we are looping through placing code chunks onto a global queue via async operation. Thus,

for i in 0...3 {

// code chunk gets placed onto the global queue

}

Then these 4 code chunks gets processed by the global queue asynchronously. Their initial lines gets printed:

—– code execution entered dispatchGroup for index 0 ——
—– code execution entered dispatchGroup for index 2 ——
—– code execution entered dispatchGroup for index 3 ——
—– code execution entered dispatchGroup for index 1 ——
code execution 0 start
code execution 2 start
code execution 3 start
code execution 1 start

This means that for each code chunk, that code chunk has placed a section of code into the dispatchGroup. In our case, the section of code prints 0 to 100.
The dispatchGroup now has 4 section of code to process.

dispatchGroup.enter()

// section of code

dispatchGroup.leave()

The dispatchGroup will now execute the 4 section of code asynchronously.

Due to code chunk 0’s NO SLEEP, it simply does its printing first and it does it fast. Code chunk 1 can’t start because it requires every loop to sleep for 0.01 seconds before it starts. Thus, since code chunk 0’s loop does 0 sleep, it prints all first.

Then code chunk 1 starts, and sleeps for 0.01 between each print. Code chunk 2 will also start, and it sleeps for 0.02 between each print….

Due to

index 1’s loop having to sleep 0.01ms,
index 2’s loop having to sleep 0.02ms,
index 3’s loop having to sleep 0.03ms,

for every iteration, you can see that index 1’s printing of its loop is just a tad bit faster than index 2 and index 3’s loops.

index 1’s code chunk finishes and thus, it leaves the group.

eventually index 2’s code also finishes and leaves the group. Then index 3 will finally group after printing its loop.

Then when the group is finally empty, it will notify us and process the code block to print “Block 4”. Since this command is within the for loop, it will print 4 times.

Of course you can also remove the sleep line, if that’s the case, all of code chunks on the global queue will be processed asynchronously and they will all finish in similar time to no sleep for any of them. It still holds that once ALL of them are finished, they will notify, and thus, the notify code blocks will run.

output

—— code execution left dispatchGroup for index 0 ——–
loop index 0—- code chunk 1—
loop index 0—- code chunk 2—
loop index 1—- code chunk 1—
loop index 0—- code chunk 3—
….
loop index 100—- code chunk 1—
code execution 1 finish

—— code execution left dispatchGroup for index 1 ——–
loop index 51—- code chunk 2—
loop index 35—- code chunk 3—
loop index 52—- code chunk 2—
…
loop index 68—- code chunk 3—
loop index 100—- code chunk 2—
code execution 2 finish

—— code execution left dispatchGroup for index 2 ——–
loop index 69—- code chunk 3—
loop index 70—- code chunk 3—
loop index 71—- code chunk 3—
…
loop index 98—- code chunk 3—
loop index 99—- code chunk 3—
loop index 100—- code chunk 3—
code execution 3 finish

—— code execution left dispatchGroup for index 3 ——–

Block 4
Block 4
Block 4
Block 4