NSOperationQueue tüm görevleri bitirdiğinde bildirim alın

NSOperationQueuevar waitUntilAllOperationsAreFinished, ancak bunun için eşzamanlı olarak beklemek istemiyorum. Sıra bittiğinde kullanıcı arayüzündeki ilerleme göstergesini gizlemek istiyorum.

Bunu başarmanın en iyi yolu nedir?

E-postalarımdan bildirim gönderemiyorum NSOperationçünkü hangisinin en son olacağını bilmiyorum ve [queue operations]bildirim alındığında henüz boş (veya daha kötüsü - yeniden doldurulmuş) olmayabilir.

Sıranızın özelliğini gözlemlemek için KVO kullanın operations, ardından kuyruğunuzun tamamlanıp tamamlanmadığını kontrol ederek anlayabilirsiniz [queue.operations count] == 0.

KVO'yu içinde yaptığınız dosyanın bir yerinde, KVO için aşağıdaki gibi bir bağlam bildirin ( daha fazla bilgi ):

static NSString *kQueueOperationsChanged = @"kQueueOperationsChanged";

Sıranızı oluşturduğunuzda şunu yapın:

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

Daha sonra bunu şu şekilde yapın 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];
    }
}

(Bu, adınızın NSOperationQueueadlı bir mülkte olduğunu varsayar queue)

Nesneniz tamamen ayrıştırılmadan önce (veya kuyruk durumunu önemsemeyi bıraktığında) bir noktada, KVO'daki kaydı şu şekilde silmeniz gerekir:

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

Ek: iOS 4.0, NSOperationQueue.operationCountbelgelere göre KVO uyumlu bir özelliğe sahiptir . Bu cevap yine de iOS 4.0'da çalışacaktır, bu nedenle geriye dönük uyumluluk için hala yararlıdır.

Bu davranışa uyan bir şey bekliyorsanız (veya arzuluyorsanız):

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>

Bir kuyruğa birkaç "kısa" işlem ekleniyorsa, bunun yerine şu davranışı görebileceğinizi bilmelisiniz (çünkü işlemler kuyruğa eklenmenin bir parçası olarak başlatılır):

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>

Projemde, bir seri NSOperationQueue'ya (yani, maxConcurrentOperationCount = 1) çok sayıda işlem eklendikten sonra ve yalnızca hepsi tamamlandığında son işlemin ne zaman tamamlandığını bilmem gerekiyordu.

Google'da "seri bir NSoperationQueue FIFO mu?" Sorusuna yanıt olarak bir Apple geliştiricisinden gelen bu ifadeyi buldum. -

Tüm işlemler aynı önceliğe sahipse (işlem bir kuyruğa eklendikten sonra değiştirilmez) ve tüm işlemler her zaman - isReady == YES işlem kuyruğuna girdiklerinde, o zaman bir seri NSOperationQueue FIFO'dur.

Chris Kane Kakao Çerçeveleri, Apple

Benim durumumda, kuyruğa son işlemin ne zaman eklendiğini bilmek mümkündür. Bu yüzden, son işlem eklendikten sonra, kuyruğun boşaltıldığına dair bildirim göndermekten başka hiçbir şey yapmayan daha düşük öncelikli başka bir işlemi kuyruğa ekliyorum. Apple'ın beyanına göre, bu, yalnızca tüm işlemler tamamlandıktan sonra yalnızca tek bir bildirimin gönderilmesini sağlar.

İşlemler, sonuncuyu tespit etmeye izin vermeyecek bir şekilde ekleniyorsa (yani, deterministik olmayan), o zaman yukarıda belirtilen KVO yaklaşımları ile gitmeniz gerektiğini düşünüyorum, daha fazla olup olmadığını tespit etmeye çalışmak için ek koruma mantığı ile işlemler eklenebilir.

:)

En son çalışması için diğerlerine bağımlı olan bir NSOperation eklemeye ne dersiniz?

Bir alternatif, GCD kullanmaktır. Bakınız , bu referans olarak kullanılmaktadır.

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

Ben böyle yaparım.

Sırayı ayarlayın ve operasyonlar özelliğindeki değişiklikler için kaydolun:

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

... ve gözlemci (bu durumda self) şunları uygular:

- (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;
}

Bu örnekte "spinner" bir UIActivityIndicatorViewşeylerin olduğunu gösteriyor. Açıkçası size uyacak şekilde değiştirebilirsiniz ...

İtibariyle iOS 13.0 , operationCount ve operasyon özellikleri kaldırılmıştır. Sıranızdaki işlemlerin sayısını kendiniz takip etmek ve hepsi tamamlandığında bir Bildirim göndermek kadar basit . Bu örnek, Operation'ın eşzamansız bir alt sınıflamasıyla da çalışır.

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

Aşağıda, kolay eşzamansız işlemler için bir Operasyon alt sınıfı bulunmaktadır

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

}

Bunu yapmak için bir kategori kullanıyorum.

NSOperationQueue + Completion.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 + Tamamlanma.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

Kullanım :

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!)
}];

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

Sıranın özelliğini gözlemlemek için KVO kullanmaya ne dersiniz operationCount? Sonra sıra boşaldığında ve ayrıca boş kalmayı bıraktığında bunu duyarsınız. İlerleme göstergesiyle uğraşmak, aşağıdakilere benzer bir şey yapmak kadar basit olabilir:

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

Son işlemi şu şekilde ekleyin:

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

Yani:

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

}

ReactiveObjC ile bunun işe yaradığını görüyorum:

// 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!");
    }
}];

Bilginize, Sen OBEB ile bunu başarabilirsiniz dispatch_group içinde swift 3 . Tüm görevler bittiğinde bildirim alabilirsiniz.

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

Yeni bir tane oluşturabilir NSThreadveya arka planda bir seçici çalıştırabilir ve orada bekleyebilirsiniz. Bittiğinde, NSOperationQueuekendi bildiriminizi gönderebilirsiniz.

Şöyle bir şey düşünüyorum:

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

...

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

Bu İşlemi temel sınıfınız olarak whenEmpty {}kullanırsanız, OperationQueue'ya blok iletebilirsiniz :

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

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

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

KVO olmadan

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

Buraya kombine ile bir çözüm arıyorsanız - sadece kendi durum nesnemi dinledim.

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

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