Swift 4: Creating an asynchronous serial queue with 2 seconds wait after each job - swift

Question

Have had trouble visualising this...
I think I need 2 threads and am not sure how to implement them.
I need to have a 2 second delay minimum in between each network retrieval requests after it has been completed.
Main Thread:
UIButton pressed --> Function adds a network retrieval request to a serial queue --> UILoop continues...
Network Thread:
Checks queue for next request --> Begins request --> Finishes request --> Waits 2 seconds --> Checks queue for next request --> Begins request --> Finishes request --> Waits 2 seconds --> Checks queue for next request --> No request --> Checks queue for next request... or Ends loop until recalled.
var networkQueue = [NetworkRequest]()
var networkQueueActive = false
#IBAction func buttonPressed(_ sender: UIButton) {
networkQueue.append(NetworkRequest(UIButton))
if networkQueueActive == false {
networkRetrieveFromQueue() // need to asynchronously call this DON'T KNOW HOW TO DO THIS
}
}
func networkRetrieveFromQueue() {
networkQueueActive = true
while !networkQueue.isEmpty {
let request = networkQueue.remove(at: 0)
// synchronous network data retrieval on this thread KNOW HOW TO DO THIS
// do something with the data retrieved KNOW HOW TO DO THIS
// wait 2 seconds DON'T KNOW HOW TO DO THIS
}
networkQueueActive = false
}

Answer 1

If you have
var networkQueue = [NetworkRequest]()
var networkQueueActive = false
Then, your networkRetrieveFromQueue should:
check to see if the queue is empty;
if not, grab the first item in the queue;
initiate the asynchronous request; and
in the completion handler of that asynchronous request, call networkRetrieveFromQueue again after 2 seconds
Thus
func startQueue() {
if networkQueueActive { return }
networkQueueActive = true
processNext()
}
// if queue not empty, grab first item, perform request, and call itself
// 2 seconds after prior one finishes
func processNext() {
if networkQueue.isEmpty {
networkQueueActive = false
return
}
let request = networkQueue.removeFirst()
get(request: request) {
DispatchQueue.main.asyncAfter(deadline: .now() + 2) {
self.processNext()
}
}
}
Where your "process request" might look like:
// perform asynchronous network request, with completion handler that is
// called when its done
func get(request: NetworkRequest, completionHandler: #escaping () -> Void) {
let task = URLSession.shared.dataTask(with: request.request) { data, _, error in
guard let data = data, error == nil else {
print(error ?? "Unknown error")
completionHandler()
return
}
// process successful response here
// when done, call completion handler
completionHandler()
}
task.resume()
}
Now, I don't know what your NetworkRequest looks like, but this illustrates the basic idea of how to recursively call a function in the completion handler of some asynchronous method.