How do I use DispatchGroup in background thread?

Question

I have two functions (or tasks) that I want to run one after the other and i'm using DispatchGroup to track them and notify me when they're complete. Right now they're being done in the Main thread but I want to run these tasks in a background thread. How would I go about doing so? I've tried a few approaches but they either run simultaneously or I get an exception error after the first one completes. The following code performs the tasks one after the other but if I call Thread.current inside the functions I can see that they are being run in the Main thread.

@objc func doWorkFunctions(){
    taskGroup.enter()
    DispatchQueue.global(qos: .background).sync {
        self.firstFunction {
            self.taskGroup.leave()
        }
    }

    taskGroup.enter()
    DispatchQueue.global(qos: .background).sync {
        self.secondFunction {
            self.taskGroup.leave()
        }
    }

    taskGroup.notify(queue: .main) {
        print("All tasks completed")
    }
}

If I use the following code they are run simultaneously but in the background thread.

@objc func doWorkFunctions(){
    taskGroup.enter()
    DispatchQueue.global(qos: .background).async {
        self.firstFunction {
            self.taskGroup.leave()
        }
    }

    taskGroup.enter()
    DispatchQueue.global(qos: .background).async {
        self.secondFunction {
            self.taskGroup.leave()
        }
    }

    taskGroup.notify(queue: .main) {
        print("All tasks completed")
    }
}

I've been searching and searching but I can't seem to find an answer to my problem or clarity for that matter. Can someone provide some guidance as to what's going on here. These are the functions in question in case. They simulate a long task to practice tracking progress.

func firstFunction(completion: @escaping()->Void){
    print(Thread.current)
    if childProgressOne.isCancelled { return }
    for i in 1...5 {
        sleep(1)

        childProgressOne.completedUnitCount = Int64(i * 20)

        print("Child Progress One: \(childProgressOne.fractionCompleted)")
        print("Total Progress: \(totalProgress.fractionCompleted)")
    }
    completion()
}

func secondFunction(completion: @escaping()->Void){
    print(Thread.current)

    if childProgressTwo.isCancelled { return }
    for i in 1...5 {
        sleep(1)

        childProgressTwo.completedUnitCount = Int64(i * 20)

        print("Child Progress Two: \(childProgressTwo.fractionCompleted)")
        print("Total Progress: \(totalProgress.fractionCompleted)")
    }
    completion()
}

This also performs them in order but calling Thread.current inside the functions tells me they are being performed in the Main thread even though they are being called to a background thread.

 @objc func doWorkFunctions(){
    DispatchQueue.global(qos: .background).sync {
        self.taskGroup.enter()
        self.firstFunction {
            self.taskGroup.leave()
        }
        self.taskGroup.enter()
        self.secondFunction {
            self.taskGroup.leave()
        }
    }

    taskGroup.notify(queue: .main) {
        print("All tasks completed")
    }
}

Answer 1

Given what you've described, I probably wouldn't use a dispatch group at all here. I'd just chain the methods:

@objc func doWorkFunctions() {
    DispatchQueue.global(qos: .background).async {
        self.firstFunction {
            self.secondFunction {
                DispatchQueue.main.async {
                    print("All tasks completed")
                }
        }
    }
}

But assuming you have a good reason for a group here, what you need to do is to use .notify to synchronize them. .notify says "when the group is empty, submit this block to this queue."

@objc func doWorkFunctions(){
    let queue = DispatchQueue.global(qos: .background)

    taskGroup.enter()
    queue.async {
        self.firstFunction {
            self.taskGroup.leave()
        }
    }

    taskGroup.notify(queue: queue) {
        self.taskGroup.enter()

        self.secondFunction {
            self.taskGroup.leave()
        }

        self.taskGroup.notify(queue: .main) {
            print("All tasks completed")
        }
    }
}

(You probably don't need taskGroup to be an instance property here. You could make it a local variable and have fewer self. references required. Each block has a reference to the group, so it will live until all the blocks have completed.)

Answer 2

If all you want to do is run two functions in serial in the background, then all you need to do is execute them in order in the same task within the same queue. There isn't any need to get fancy at all.

You can plug this into a playground and mess around with it:

import UIKit
import PlaygroundSupport

PlaygroundPage.current.needsIndefiniteExecution = true

func firstFunction(completion: @escaping() -> Void) {
    for i in 1...5 {
        sleep(1)
        print(i, Thread.current)
    }
    completion()
}

func secondFunction(completion: @escaping() -> Void) {
    for i in 1...5 {
        sleep(1)
        print(i + 100, Thread.current)
    }
    completion()
}

func doWorkFunctions() {

    let serialQueue = DispatchQueue(label: "serial")
    //let concurrentQueue = DispatchQueue.global(qos: .default) <-- this will produce the same result

    serialQueue.async {
        firstFunction(completion: {
            print("first function done")
        })
        secondFunction(completion: {
            print("second function done")
        })
    }

}

doWorkFunctions()

Whether you execute these two functions in a serial queue or a concurrent queue, and whether you dispatch them in sync or async, is trivial as far as your question is concerned if you place them in the same task in the same queue. If you, however, separated the two functions into two separate tasks (or queues, for that matter), then serialization and concurrency become a factor. However, as a caveat, the term "concurrent" is relative. All tasks executed through dispatch queues (serial or concurrent) are concurrent to the main thread. But when we talk about them in the context of dispatch queues, we almost always mean concurrent to other tasks.

Read this to get a better understanding of what exactly queueing is: https://stackoverflow.com/a/53582047/9086770

Answer 3

This solution is a combination of the first two answers. I used what @nard posted in the second answer but also using DispatchGroup. I realize in this scenario DispatchGroup isn't really needed but if in case it was, this would be a way to do it. Thanks to @Rob Napier and @nard for the guidance.

import UIKit
func workOne(completion: @escaping ()->Void){
    print(Thread.current)
    for i in 1...4{
        sleep(1)
        print(i)
    }
    completion()
}
func workTwo(completion: @escaping ()->Void){
    print(Thread.current)
    for i in 5...8{
        sleep(1)
        print(i)
    }
    completion()
}
func doWork(){
    let dispatchGroup = DispatchGroup()

    dispatchGroup.enter()
    workOne {
        dispatchGroup.leave()
    }
    dispatchGroup.enter()
    workTwo {
        dispatchGroup.leave()
    }
    dispatchGroup.notify(queue: .main) {
        print(Thread.current)
        print("completed!")
    }
}
DispatchQueue.global(qos: .default).async {
    doWork()
}