同步排队异步操作

Question

I have a list/array of items which are being displayed on a UITableView. Each item contains a state machine inside it which does some asynchronous task using futures and promises mechanism and it's state being shown on respective UITableViewCell. Currently for one model it works perfectly fine.

However, I need to do this as a batching sequence. For example there can be 15 models in an array however at a particular momement I'll be able to start only 3, once either models completes or fails I should manually trigger the 4th model to initiate it's task. Note: I cannot initiate all of the 15 models operation and just wait for callback as it's limitation by hardware and immediately fail in that scenario.

To be specific if the above is not clear, below are two examples: My problem statement kind of exactly matches the Update all feature under Updates tab in App Store app of iPhone. If you have 20 app updates and tap on 'update all' button it shows 17 apps in waiting state and runs update downloads only on 3 apps at any moment. Once a app update completes, it moves to the next one. This is the exact replica of my problem statement, however with a small twist.

Twist: My operations are hardware related operations over bluetooth. Think like you have 20 Wearable devices you want to configure with writing some data over bluetooth. Hardware limitation is, you can connect to max 3-4 devices at a time. Hence once a device/peripheral succeeds or fails with operation I should try to connect 4 one and so n so progressively until all are done. There's retry function as well which queue back the failed one.

My problem is how I should structure to maintain this and monitor. I have a general understanding of concurrency, however haven't worked much on it. My current feeling is to use a Queue and counters wrapped in a Manager class to monitor the states. Would like some help on how to approach this. Also I don't need code, just the conceptual solution to the data structure.

Answer 1

Use OperationQueue and for each kind of operation you have subclass Operation . With operations you can add dependencies on other operations to finish. So for example, if you wanted to wait until the 3rd operation is finished to start the 4th, 5th, and 6th operation you would just add the 3rd operation as their dependency.

Edit: So to group operations together you can make a separate class for it. I have added a code sample below. The add(dependency: OperationGroup) function tells the other group to start executing an operation as soon as an operation is finished executing in the original group.

//Make a subclass for each kind of operation.
class BluetoothOperation: Operation
{
    let number: Int

    init(number: Int)
    {
        self.number = number
    }

    override func main() 
    {
        print("Executed bluetooth operation number \(number)")
    }
}

class OperationGroup
{
    var operationCounter: Int = 0
    var operations: [Operation]
    let operationQueue: OperationQueue = OperationQueue()

    init(operations: [Operation])
    {
        self.operations = operations
    }

    func executeAllOperations()
    {
        operationQueue.addOperations(operations, waitUntilFinished: true)
    }

    //This in essence is popping the "Stack" of operations you have.
    func pop() -> Operation?
    {
        guard operationCounter < operations.count else { return nil }

        let operation = operations[operationCounter]

        operationCounter += 1

        return operation
    }

    func add(dependency: OperationGroup)
    {
        dependency.operations.forEach(
        {
            $0.completionBlock =
            {
                if let op = self.pop()
                {
                    dependency.operationQueue.addOperation(op)
                }
            }
        })
    }
}


let firstOperationGroup = OperationGroup(operations: [BluetoothOperation(number: 1), BluetoothOperation(number: 2), BluetoothOperation(number: 3)])
let secondOperationGroup = OperationGroup(operations: [BluetoothOperation(number: 4), BluetoothOperation(number: 5), BluetoothOperation(number: 6)])

secondOperationGroup.add(dependency: firstOperationGroup)

firstOperationGroup.executeAllOperations()

Answer 2

I think yours is a good case for a little bit of reactive. I put together a quick example using ReactiveKit so you can have a look. Reactive kit is quite simple and is more than enough for this case. You can use any other reactive library as well. I hope it helps.

ReactiveKit: https://github.com/DeclarativeHub/ReactiveKit Bond: https://github.com/DeclarativeHub/Bond

You can run the code below in a workspace after you install reactiveKit dependencies:

import UIKit
import Bond
import ReactiveKit

class ViewController: UIViewController {

    var jobHandler : JobHandler!
    var jobs = [Job(name: "One", state: nil), Job(name: "Two", state: nil), Job(name: "Three", state: nil), Job(name: "Four", state: nil), Job(name: "Five", state: nil)]

    override func viewDidLoad() {
        super.viewDidLoad()
        self.jobHandler = JobHandler()
        self.run()
    }

    func run() {
        // Initialize jobs with queue state
        _ = self.jobs.map({$0.state.value = .queue})
        self.jobHandler.jobs.insert(contentsOf: jobs, at: 0)
        self.jobHandler.queueJobs(limit: 2) // Limit of how many jobs you can start with
    }
}

// Job state, I added a few states just as test cases, change as required
public enum State {
    case queue, running, completed, fail
}

class Job : Equatable {

    // Initialize state as a Reactive property
    var state = Property<State?>(nil)
    var name : String!

    init(name: String, state: State?) {
        self.state.value = state
        self.name = name
    }

    // This runs the current job
    typealias jobCompletion = (State) -> Void
    func runJob (completion: @escaping jobCompletion) {
        DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
            self.state.value = .completed
            completion(self.state.value ?? .fail)
            return
        }
        self.state.value = .running
        completion(.running)
    }

    // To find the index of current job
    static func == (lhs: Job, rhs: Job) -> Bool {
        return lhs.name == rhs.name
    }
}

class JobHandler {

    // The array of jobs in an observable form, so you can see event on the collection
    var jobs = MutableObservableArray<Job>([])
    // Completed jobs, you can add failed jobs as well so you can queue them again
    var completedJobs = [Job]()


    func queueJobs (limit: Int) {
        // Observe the events in the datasource
        _ = self.jobs.observeNext { (collection) in
            let jobsToRun = collection.collection.filter({$0.state.value == .queue})
            self.startJob(jobs: Array(jobsToRun.prefix(limit)))
        }.dispose()
    }

    func startJob (jobs: [Job?]) {
        // Starts a job thrown by the datasource event
        jobs.forEach { (job) in
            guard let job = job else { return }
            job.runJob { (state) in
                switch state {
                case .completed:
                    if !self.jobs.collection.isEmpty {
                        guard let index = self.jobs.collection.indexes(ofItemsEqualTo: job).first else { return }
                        print("Completed " + job.name)
                        self.jobs.remove(at: index)
                        self.completedJobs.append(job)
                        self.queueJobs(limit: 1)
                    }
                case .queue:
                    print("Queue")
                case .running:
                    print("Running " + job.name)
                case .fail:
                    print("Fail")
                }
            }
        }
    }
}

extension Array where Element: Equatable {
    func indexes(ofItemsEqualTo item: Element) -> [Int]  {
        return enumerated().compactMap { $0.element == item ? $0.offset : nil }
    }
}