CODEWITHSUNDEEP
iosswiftnsoperationqueue
Lance Samaria
Lance Samaria

Reputation: 19622

Swift -Start/Stop Synchronous OperationQueue

I have some operations that need to run synchronously. I tried to follow this link but it's not clear enough for my situation.

op2 doesn't start until op1 is finished and op3 doesn't start until op2 is finished but during that time I need to be able to stop any of the operations and restart all over again. For example if op2 is running, I know that it cannot be stopped, but for whatever reason I need to be able to prevent op3 from executing because op1 has restarted. How can I do this?

This is a very simple example, the actual code is more intricate

var queue1 = OperationQueue()
var queue2 = OperationQueue()
var queue3 = OperationQueue()
     
var operation1: BlockOperation?
var operation2: BlockOperation?
var operation3: BlockOperation?

// a DispatchGroup has finished running now it's time to start the operations ...
dispatchGroup.notify(queue: .global(qos: .background)) { [weak self] in
    DispatchQueue.main.async { [weak self] in

        self?.runFirstFunc()
    }
}

func runFirstFunc() {

   var count = 0

   let num in arr  {
       count += num
   }

   // now that the loop is finished start the second func but there is a possibility something may happen in the first that should prevent the second func from running
   runSecondFunc(count: count)
}

func runSecondFunc(count: Int) {

    do {

        try ...

        // if the do-try is successful do something with count then start thirdFunc but there is a possibility something may happen in the second func that should prevent the third func from running
        runThirdFunc()

    } catch {
        return
    }
}

func runThirdFunc() {

    // this is the final operation, once it hits here I know it can't be stopped even if I have to restart op1 again but that is fine
}

Upvotes: 0

Views: 958

Answers (3)

Rob
Rob

Reputation: 438232

You said:

op2 doesn't start until op1 is finished and op3 doesn't start until op2 is finished ...

If using OperationQueue you can accomplish that by creating the three operations, and defining op1 to be a dependency of op2 and defining op2 as a dependency of op3.

... but during that time I need to be able to stop any of the operations and restart all over again.

If using OperationQueue, if you want to stop all operations that have been added to the queue, you call cancelAllOperations.

For example if op2 is running, I know that it cannot be stopped, ...

Well, it depends upon what op2 is doing. If it's spinning in a loop doing calculations, then, yes, it can be canceled, mid-operation. You just check isCancelled, and if it is, stop the operation in question. Or if it is a network request (or something else that is cancelable), you can override cancel method and cancel the task, too. It depends upon what the operation is doing.

... but for whatever reason I need to be able to prevent op3 from executing because op1 has restarted.

Sure, having canceled all the operations with cancelAllOperations, you can then re-add three new operations (with their associated dependencies) to the queue.

Upvotes: 1

CouchDeveloper
CouchDeveloper

Reputation: 19164

Maybe, this is a good reason to look into Swift Combine:

  • Define your tasks as Publishers.
  • Use flatMap to chain them, optionally pass output from previous to the next.
  • Use switchToLatest to restart the whole thing and cancel the previous one when it is still running - if any.
  • Use cancel on the subscriber to cancel the whole thing.

Upvotes: 0

Tarun Tyagi
Tarun Tyagi

Reputation: 10112

Here's a not-tested implementation that allows cancellation while any task is doing it's subtasks (repeatedly).

In case second task fails/throws, it automatically restarts from the first task.

In case user manually stops / starts, the last in-flight task quits it's execution (as soon as it can).

Note : You must take care of [weak self] part according to your own implementation.

import Foundation

class TestWorker {
    let workerQueue = DispatchQueue.global(qos: .utility)
    var currentWorkItem: DispatchWorkItem?
    
    func start() {
        self.performTask { self.performTask1() }
    }
    
    func stop() {
        currentWorkItem?.cancel()
    }
    
    func performTask(block: @escaping (() -> Void)) {
        let workItem = DispatchWorkItem(block: block)
        self.currentWorkItem = workItem
        workerQueue.async(execute: workItem)
    }
    
    func performTask1() {
        guard let workItem = self.currentWorkItem else { return }
        func subtask(index: Int) {}
        for i in 0..<100 {
            if workItem.isCancelled { return }
            subtask(index: i)
        }
        self.performTask { self.performTask2() }
    }
    
    func performTask2() {
        guard let workItem = self.currentWorkItem else { return }
        func subtask(index: Int) throws {}
        for i in 0..<100 {
            if workItem.isCancelled { return }
            do { try subtask(index: i) }
            catch { 
                self.start()
                return
            }
        }
        self.performTask { self.performTask3() }
    }
    
    func performTask3() {
        guard let workItem = self.currentWorkItem else { return }
        func subtask(index: Int) {}
        for i in 0..<100 {
            if workItem.isCancelled { return }
            subtask(index: i)
        }
        /// Done
    }
}

Upvotes: 0

Related Questions