Dapatkan pemberitahuan ketika NSOperationQueue menyelesaikan semua tugas

NSOperationQueuemiliki waitUntilAllOperationsAreFinished, tetapi saya tidak ingin menunggu secara bersamaan. Saya hanya ingin menyembunyikan indikator kemajuan di UI saat antrian selesai.

Apa cara terbaik untuk mencapai ini?

Saya tidak bisa mengirim notifikasi dari NSOperations saya , karena saya tidak tahu mana yang akan terakhir, dan [queue operations]mungkin belum kosong (atau lebih buruk - terisi kembali) ketika notifikasi diterima.

Gunakan KVO untuk mengamati operationsproperti antrian Anda, lalu Anda dapat mengetahui apakah antrian Anda telah selesai dengan memeriksa [queue.operations count] == 0.

Di suatu tempat di file tempat Anda melakukan KVO, nyatakan konteks untuk KVO seperti ini ( info selengkapnya ):

static NSString *kQueueOperationsChanged = @"kQueueOperationsChanged";

Saat Anda mengatur antrian Anda, lakukan ini:

[self.queue addObserver:self forKeyPath:@"operations" options:0 context:&kQueueOperationsChanged];

Kemudian lakukan ini di observeValueForKeyPath:

- (void) observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object 
                         change:(NSDictionary *)change context:(void *)context
{
    if (object == self.queue && [keyPath isEqualToString:@"operations"] && context == &kQueueOperationsChanged) {
        if ([self.queue.operations count] == 0) {
            // Do something here when your queue has completed
            NSLog(@"queue has completed");
        }
    }
    else {
        [super observeValueForKeyPath:keyPath ofObject:object 
                               change:change context:context];
    }
}

(Ini mengasumsikan bahwa Anda NSOperationQueueada di properti bernama queue)

Di beberapa titik sebelum objek Anda sepenuhnya deallocs (atau ketika berhenti peduli tentang status antrian), Anda harus membatalkan pendaftaran dari KVO seperti ini:

[self.queue removeObserver:self forKeyPath:@"operations" context:&kQueueOperationsChanged];

Tambahan: iOS 4.0 memiliki NSOperationQueue.operationCountproperti, yang menurut dokumen sesuai dengan KVO. Namun, jawaban ini masih akan berfungsi di iOS 4.0, jadi masih berguna untuk kompatibilitas ke belakang.

Jika Anda mengharapkan (atau menginginkan) sesuatu yang cocok dengan perilaku ini:

t=0 add an operation to the queue.  queueucount increments to 1
t=1 add an operation to the queue.  queueucount increments to 2
t=2 add an operation to the queue.  queueucount increments to 3
t=3 operation completes, queuecount decrements to 2
t=4 operation completes, queuecount decrements to 1
t=5 operation completes, queuecount decrements to 0
<your program gets notified that all operations are completed>

Anda harus menyadari bahwa jika sejumlah operasi "pendek" sedang ditambahkan ke antrian Anda mungkin melihat perilaku ini sebagai gantinya (karena operasi dimulai sebagai bagian dari penambahan ke antrian):

t=0  add an operation to the queue.  queuecount == 1
t=1  operation completes, queuecount decrements to 0
<your program gets notified that all operations are completed>
t=2  add an operation to the queue.  queuecount == 1
t=3  operation completes, queuecount decrements to 0
<your program gets notified that all operations are completed>
t=4  add an operation to the queue.  queuecount == 1
t=5  operation completes, queuecount decrements to 0
<your program gets notified that all operations are completed>

Dalam proyek saya, saya perlu mengetahui kapan operasi terakhir selesai, setelah sejumlah besar operasi telah ditambahkan ke serial NSOperationQueue (yaitu, maxConcurrentOperationCount = 1) dan hanya ketika semuanya telah selesai.

Googling Saya menemukan pernyataan ini dari pengembang Apple sebagai tanggapan atas pertanyaan "apakah serial NSoperationQueue FIFO?" -

Jika semua operasi memiliki prioritas yang sama (yang tidak berubah setelah operasi ditambahkan ke antrian) dan semua operasi selalu - isReady == YES pada saat mereka dimasukkan ke dalam antrian operasi, maka NSOperationQueue serial adalah FIFO.

Kerangka Kakao Chris Kane, Apple

Dalam kasus saya, dimungkinkan untuk mengetahui kapan operasi terakhir ditambahkan ke antrian. Jadi setelah operasi terakhir ditambahkan, saya menambahkan operasi lain ke antrian, dengan prioritas lebih rendah, yang tidak melakukan apa-apa selain mengirim pemberitahuan bahwa antrian telah dikosongkan. Berdasarkan pernyataan Apple, ini memastikan bahwa hanya satu pemberitahuan yang dikirim hanya setelah semua operasi selesai.

Jika operasi ditambahkan dengan cara yang tidak memungkinkan untuk mendeteksi yang terakhir, (yaitu, non-deterministik) maka saya pikir Anda harus menggunakan pendekatan KVO yang disebutkan di atas, dengan logika penjaga tambahan ditambahkan untuk mencoba mendeteksi jika lebih jauh operasi dapat ditambahkan.

:)

Bagaimana jika menambahkan NSOperation yang bergantung pada semua yang lain sehingga akan berjalan terakhir?

Salah satu alternatifnya adalah dengan menggunakan GCD. Lihat ini sebagai referensi.

dispatch_queue_t queue = dispatch_get_global_queue(0,0);
dispatch_group_t group = dispatch_group_create();

dispatch_group_async(group,queue,^{
 NSLog(@"Block 1");
 //run first NSOperation here
});

dispatch_group_async(group,queue,^{
 NSLog(@"Block 2");
 //run second NSOperation here
});

//or from for loop
for (NSOperation *operation in operations)
{
   dispatch_group_async(group,queue,^{
      [operation start];
   });
}

dispatch_group_notify(group,queue,^{
 NSLog(@"Final block");
 //hide progress indicator here
});

Beginilah cara saya melakukannya.

Siapkan antrian, dan daftarkan untuk perubahan di properti operasi:

myQueue = [[NSOperationQueue alloc] init];
[myQueue addObserver: self forKeyPath: @"operations" options: NSKeyValueObservingOptionNew context: NULL];

... dan pengamat (dalam hal ini self) mengimplementasikan:

- (void) observeValueForKeyPath:(NSString *) keyPath ofObject:(id) object change:(NSDictionary *) change context:(void *) context {

    if (
        object == myQueue
        &&
        [@"operations" isEqual: keyPath]
    ) {

        NSArray *operations = [change objectForKey:NSKeyValueChangeNewKey];

        if ( [self hasActiveOperations: operations] ) {
            [spinner startAnimating];
        } else {
            [spinner stopAnimating];
        }
    }
}

- (BOOL) hasActiveOperations:(NSArray *) operations {
    for ( id operation in operations ) {
        if ( [operation isExecuting] && ! [operation isCancelled] ) {
            return YES;
        }
    }

    return NO;
}

Dalam contoh ini "pemintal" adalah UIActivityIndicatorViewpertunjukan bahwa sesuatu sedang terjadi. Jelas Anda dapat berganti untuk menyesuaikan ...

Saya menggunakan kategori untuk melakukan ini.

NSOperationQueue + Penyelesaian. H

//
//  NSOperationQueue+Completion.h
//  QueueTest
//
//  Created by Artem Stepanenko on 23.11.13.
//  Copyright (c) 2013 Artem Stepanenko. All rights reserved.
//

typedef void (^NSOperationQueueCompletion) (void);

@interface NSOperationQueue (Completion)

/**
 * Remarks:
 *
 * 1. Invokes completion handler just a single time when previously added operations are finished.
 * 2. Completion handler is called in a main thread.
 */

- (void)setCompletion:(NSOperationQueueCompletion)completion;

@end

NSOperationQueue + Penyelesaian.m

//
//  NSOperationQueue+Completion.m
//  QueueTest
//
//  Created by Artem Stepanenko on 23.11.13.
//  Copyright (c) 2013 Artem Stepanenko. All rights reserved.
//

#import "NSOperationQueue+Completion.h"

@implementation NSOperationQueue (Completion)

- (void)setCompletion:(NSOperationQueueCompletion)completion
{
    NSOperationQueueCompletion copiedCompletion = [completion copy];

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [self waitUntilAllOperationsAreFinished];

        dispatch_async(dispatch_get_main_queue(), ^{
            copiedCompletion();
        });
    });
}

@end

Penggunaan :

NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
    // ...
}];

NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
    // ...
}];

[operation2 addDependency:operation1];

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperations:@[operation1, operation2] waitUntilFinished:YES];

[queue setCompletion:^{
    // handle operation queue's completion here (launched in main thread!)
}];

Sumber: https://gist.github.com/artemstepanenko/7620471

Mulai iOS 13.0 , properti operationCount dan operasi tidak digunakan lagi. Sangat mudah untuk melacak sendiri jumlah operasi dalam antrean Anda dan mengaktifkan Notifikasi ketika semuanya telah selesai. Contoh ini juga bekerja dengan subclass Asynchronous dari Operation .

class MyOperationQueue: OperationQueue {
            
    public var numberOfOperations: Int = 0 {
        didSet {
            if numberOfOperations == 0 {
                print("All operations completed.")
                
                NotificationCenter.default.post(name: .init("OperationsCompleted"), object: nil)
            }
        }
    }
    
    public var isEmpty: Bool {
        return numberOfOperations == 0
    }
    
    override func addOperation(_ op: Operation) {
        super.addOperation(op)
        
        numberOfOperations += 1
    }
    
    override func addOperations(_ ops: [Operation], waitUntilFinished wait: Bool) {
        super.addOperations(ops, waitUntilFinished: wait)
        
        numberOfOperations += ops.count
    }
    
    public func decrementOperationCount() {
        numberOfOperations -= 1
    }
}

Di bawah ini adalah subkelas Operasi untuk pengoperasian asinkron yang mudah

class AsyncOperation: Operation {
    
    let queue: MyOperationQueue

enum State: String {
    case Ready, Executing, Finished
    
    fileprivate var keyPath: String {
        return "is" + rawValue
    }
}

var state = State.Ready {
    willSet {
        willChangeValue(forKey: newValue.keyPath)
        willChangeValue(forKey: state.keyPath)
    }
    
    didSet {
        didChangeValue(forKey: oldValue.keyPath)
        didChangeValue(forKey: state.keyPath)
        
        if state == .Finished {
            queue.decrementOperationCount()
        }
    }
}

override var isReady: Bool {
    return super.isReady && state == .Ready
}

override var isExecuting: Bool {
    return state == .Executing
}

override var isFinished: Bool {
    return state == .Finished
}

override var isAsynchronous: Bool {
    return true
}

public init(queue: MyOperationQueue) {
    self.queue = queue
    super.init()
}

override func start() {
    if isCancelled {
        state = .Finished
        return
    }
    
    main()
    state = .Executing
}

override func cancel() {
    state = .Finished
}

override func main() {
    fatalError("Subclasses must override main without calling super.")
}

}

Bagaimana dengan menggunakan KVO untuk mengamati operationCountproperti antrian? Kemudian Anda akan mendengarnya saat antrean kosong, dan juga saat antrean sudah tidak lagi kosong. Berurusan dengan indikator kemajuan mungkin sesederhana melakukan sesuatu seperti:

[indicator setHidden:([queue operationCount]==0)]

Tambahkan operasi terakhir seperti:

NSInvocationOperation *callbackOperation = [[NSInvocationOperation alloc] initWithTarget:object selector:selector object:nil];

Begitu:

- (void)method:(id)object withSelector:(SEL)selector{
     NSInvocationOperation *callbackOperation = [[NSInvocationOperation alloc] initWithTarget:object selector:selector object:nil];
     [callbackOperation addDependency: ...];
     [operationQueue addOperation:callbackOperation]; 

}

Dengan ReactiveObjC saya menemukan ini berfungsi dengan baik:

// skip 1 time here to ignore the very first call which occurs upon initialization of the RAC block
[[RACObserve(self.operationQueue, operationCount) skip:1] subscribeNext:^(NSNumber *operationCount) {
    if ([operationCount integerValue] == 0) {
         // operations are done processing
         NSLog(@"Finished!");
    }
}];

FYI, Anda dapat mencapai ini dengan dispatch_group GCD dalam 3 cepat . Anda bisa mendapatkan pemberitahuan ketika semua tugas telah selesai.

let group = DispatchGroup()

    group.enter()
    run(after: 6) {
      print(" 6 seconds")
      group.leave()
    }

    group.enter()
    run(after: 4) {
      print(" 4 seconds")
      group.leave()
    }

    group.enter()
    run(after: 2) {
      print(" 2 seconds")
      group.leave()
    }

    group.enter()
    run(after: 1) {
      print(" 1 second")
      group.leave()
    }


    group.notify(queue: DispatchQueue.global(qos: .background)) {
      print("All async calls completed")
}

Anda dapat membuat yang baru NSThread, atau menjalankan selektor di latar belakang, dan menunggu di sana. Jika sudah NSOperationQueueselesai, Anda bisa mengirimkan notifikasi Anda sendiri.

Saya sedang memikirkan sesuatu seperti:

- (void)someMethod {
    // Queue everything in your operationQueue (instance variable)
    [self performSelectorInBackground:@selector(waitForQueue)];
    // Continue as usual
}

...

- (void)waitForQueue {
    [operationQueue waitUntilAllOperationsAreFinished];
    [[NSNotificationCenter defaultCenter] postNotification:@"queueFinished"];
}

Jika Anda menggunakan Operation ini sebagai kelas dasar Anda, Anda bisa meneruskan whenEmpty {}blok ke OperationQueue :

let queue = OOperationQueue()
queue.addOperation(op)
queue.addOperation(delayOp)

queue.addExecution { finished in
    delay(0.5) { finished() }
}

queue.whenEmpty = {
    print("all operations finished")
}

Tanpa KVO

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)
    }
}

Jika Anda sampai di sini mencari solusi dengan menggabungkan - saya akhirnya hanya mendengarkan objek negara saya sendiri.

@Published var state: OperationState = .ready
var sub: Any?

sub = self.$state.sink(receiveValue: { (state) in
 print("state updated: \(state)")
})