Warten Sie, bis alle Operationen in der Warteschlange zu beenden, vor der Durchführung der Aufgabe

Ich habe Unterklasse eine Operation und Operation queue mit maxConcurrentOperationCount = 1.

Dieser führt meine Operationen in einer Reihenfolge, die ich hinzufügen, Sie ist gut, aber jetzt muss ich warten, bis alle Vorgänge beendet haben, vor der Ausführung von einem anderen Prozess verwendet.

ich habe versucht, verwenden Sie notification Gruppe, sondern als dies ist die Ausführung in einer for-Schleife, sobald die Operationen wurden Hinzugefügt, um die Warteschlange der benachrichtigungsgruppe feuert.. Wie muss ich warten, bis alle Operationen zum verlassen der Warteschlange vor der Ausführung von einem anderen Prozess?

for (index, _) in  self.packArray.enumerated() {

    myGroup.enter()
    let myArrayOperation = ArrayOperation(collection: self.outerCollectionView, id: self.packArray[index].id, count: index)
    myArrayOperation.name = self.packArray[index].id
    downloadQueue.addOperation(myArrayOperation)
    myGroup.leave()

}

myGroup.notify(queue: .main) {
 //do stuff here
}
InformationsquelleAutor WanderingScouse | 2017-02-27
  1. 24

    Können Sie den Betrieb Abhängigkeiten zu initiieren, die eine operation nach der Fertigstellung einer Reihe von anderen Operationen:

    let operationQueue = OperationQueue()

let completionOperation = BlockOperation {
    //do something
}

for object in objects {
    let operation = ...
    completionOperation.addDependency(operation)
    operationQueue.addOperation(operation)
}

OperationQueue.main.addOperation(completionOperation)
    • Sehr sauber. Dank
    • Hey Rob, ich habe genau das gemacht, dies aber mein completionOperation noch vorzeitig entlassen. Meine Operationen sind asynchrone Netzwerk-Operationen, so eine operation ist nur als finished wenn die Antwort zurück kommt. Ich habe gelesen, dass ich außer Kraft setzen müssen isAsynchronous Eigenschaft unter ein paar andere zu machen, eine asynchrone operation, aber ich habe gelesen, dass die Eigenschaft wird ignoriert, wenn ich den Vorgang in eine Warteschlange sowieso. Also ich bin verwirrt, was zu tun ist. Könnten Sie bitte weiter beraten?
    • was ist, wenn es gibt eine Reihe von Operationen in einer Schleife und ich will, warten Sie, bis alle Thema
    • Ich weiß nicht, was du meinst. Das ist es, was die oben hat, wartet auf das Feuer der Fertigstellung Vorgang, bis Sie fertig sind.
    • Re isAsynchronous: Es ist wahr, dass isAsynchronous wird ignoriert, wenn das hinzufügen einer Warteschlange, aber alle isExecuting, isFinished und die damit verbundenen KVO ist erforderlich, wenn das hinzufügen von Operationen, wickeln Sie einige asynchrone Prozess in eine Warteschlange. Trotzdem, ich glaube, es ist die beste Praxis zu setzen isAsynchronous zu true wenn der Betrieb, in der Tat, asynchron, (a) spiegeln die Realität der operation und (b) um sicherzustellen, dass es funktioniert, ob es verwendet wird, in einer Warteschlange oder nur manuell gestartet werden.
    InformationsquelleAutor Rob
  2. 3

    Einer geeigneten Lösung KVO

    Ersten, bevor Sie der Schleife hinzufügen der Beobachter (vorausgesetzt queue ist die OperationQueue Instanz)

    queue.addObserver(self, forKeyPath:"operations", options:.new, context:nil)

    Dann implementieren

    override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
    if object as? OperationQueue == queue && keyPath == "operations" {
        if queue.operations.isEmpty {
            //Do something here when your queue has completed
            self.queue.removeObserver(self, forKeyPath:"operations")
        }
    } else {
        super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
    }
}

    Edit:

    In der Swift 4 ist es viel einfacher

    Deklarieren einer Eigenschaft:

    var observation : NSKeyValueObservation?

    und erstellen die Beobachter

    observation = queue.observe(\.operationCount, options: [.new]) { [unowned self] (queue, change) in
    if change.newValue! == 0 {
        //Do something here when your queue has completed
        self.observation = nil
    }
}
    InformationsquelleAutor vadian
  3. 2

    Ich die nächste Lösung:

    private let queue = OperationQueue()

private func addOperations(_ operations: [Operation], completionHandler: @escaping () -> ()) {
    DispatchQueue.global().async { [unowned self] in
        self.queue.addOperations(operations, waitUntilFinished: true)
        DispatchQueue.main.async(execute: completionHandler)
    }
}
    InformationsquelleAutor kasyanov-ms
  4. 0

    Legen Sie die maximale Anzahl von gleichzeitigen Operationen zu 1

    operationQueue.maxConcurrentOperationCount = 1

    dann jeder operation ausgeführt wird, um (als wenn jeder war abhängig von der vorherigen) und Ihre Abschluss-operation ausgeführt wird, am Ende.

    InformationsquelleAutor dbolli
  5. 0

    Code an das Ende der Warteschlange
    finden Sie dieser link

    NSOperation und NSOperationQueue sind toll und nützlich, Foundation framework tools für asynchrone Aufgaben. Eine Sache verwirrt mich allerdings: Wie kann ich den code auszuführen, nachdem alle meine queue-Operationen beenden? Die Antwort ist ganz einfach: verwenden Sie die Abhängigkeiten zwischen den Operationen in der Warteschlange (einzigartiges feature von NSOperation). Es ist nur 5 code-Zeilen-Lösung.

    NSOperation Abhängigkeit trick
    mit Swift ist es nur einfach zu implementieren, wie diese:

    extension Array where Element: NSOperation {
///Execute block after all operations from the array.
func onFinish(block: () -> Void) {
    let doneOperation = NSBlockOperation(block: block)
    self.forEach { [unowned doneOperation] in doneOperation.addDependency($0) }
    NSOperationQueue().addOperation(doneOperation)
}}
    InformationsquelleAutor brahimm
  6. 0

    Meine Lösung ist ähnlich der von https://stackoverflow.com/a/42496559/452115, aber ich weiß nicht, fügen Sie die completionOperation im main OperationQueue aber in die queue selbst. Dies funktioniert für mich:

    var a = [Int](repeating: 0, count: 10)

let queue = OperationQueue()

let completionOperation = BlockOperation {
    print(a)
}

queue.maxConcurrentOperationCount = 2
for i in 0...9 {
    let operation = BlockOperation {
        a[i] = 1
    }
    completionOperation.addDependency(operation)
    queue.addOperation(operation)
}

queue.addOperation(completionOperation)

print("Done ?")
    InformationsquelleAutor Peacemoon
Schreibe einen Kommentar