รับการแจ้งเตือนเมื่อ NSOperationQueue ทำงานทั้งหมดเสร็จสิ้น

NSOperationQueueมีwaitUntilAllOperationsAreFinishedแต่ฉันไม่ต้องการรอพร้อมกัน ฉันแค่ต้องการซ่อนตัวบ่งชี้ความคืบหน้าใน UI เมื่อคิวเสร็จสิ้น

วิธีที่ดีที่สุดในการทำสิ่งนี้คืออะไร?

ฉันไม่สามารถส่งการแจ้งเตือนจากNSOperations ของฉันได้เพราะฉันไม่รู้ว่าการแจ้งเตือนใดจะเป็นครั้งสุดท้ายและ[queue operations]อาจยังไม่ว่างเปล่า (หรือแย่กว่านั้นคือการเติมใหม่) เมื่อได้รับการแจ้งเตือน

ใช้ KVO สังเกตคุณสมบัติของคิวของคุณแล้วคุณสามารถบอกได้ว่าคิวของคุณได้เสร็จสิ้นโดยตรวจสอบoperations[queue.operations count] == 0

บางแห่งในไฟล์ที่คุณกำลังทำ KVO ให้ประกาศบริบทสำหรับ KVO เช่นนี้ ( ข้อมูลเพิ่มเติม ):

static NSString *kQueueOperationsChanged = @"kQueueOperationsChanged";

เมื่อคุณตั้งค่าคิวให้ทำสิ่งนี้:

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

จากนั้นทำสิ่งนี้ใน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];
    }
}

(สมมติว่าคุณNSOperationQueueอยู่ในอสังหาริมทรัพย์ที่มีชื่อว่าqueue)

ในบางช่วงเวลาก่อนที่วัตถุของคุณจะเลิกใช้งานอย่างสมบูรณ์ (หรือเมื่อมันหยุดสนใจเกี่ยวกับสถานะคิว) คุณจะต้องยกเลิกการลงทะเบียนจาก KVO ดังนี้:

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

ภาคผนวก: iOS 4.0 มีNSOperationQueue.operationCountคุณสมบัติซึ่งตามเอกสารเป็นไปตามมาตรฐาน KVO อย่างไรก็ตามคำตอบนี้จะยังคงใช้ได้ใน iOS 4.0 ดังนั้นจึงยังมีประโยชน์สำหรับความเข้ากันได้แบบย้อนหลัง

หากคุณคาดหวัง (หรือต้องการ) บางสิ่งที่ตรงกับพฤติกรรมนี้:

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>

คุณควรทราบว่าหากมีการเพิ่มการดำเนินการ "สั้น" จำนวนหนึ่งลงในคิวคุณอาจเห็นลักษณะการทำงานนี้แทน (เนื่องจากการดำเนินการเริ่มต้นโดยเป็นส่วนหนึ่งของการเพิ่มลงในคิว):

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>

ในโครงการของฉันฉันต้องการทราบว่าเมื่อการดำเนินการครั้งสุดท้ายเสร็จสิ้นหลังจากมีการเพิ่มการดำเนินการจำนวนมากใน NSOperationQueue แบบอนุกรม (เช่น maxConcurrentOperationCount = 1) และเมื่อดำเนินการเสร็จสิ้นทั้งหมดเท่านั้น

Googling ฉันพบคำสั่งนี้จากนักพัฒนา Apple เพื่อตอบคำถาม "is a serial NSoperationQueue FIFO?" -

หากการดำเนินการทั้งหมดมีลำดับความสำคัญเท่ากัน (ซึ่งไม่มีการเปลี่ยนแปลงหลังจากเพิ่มการดำเนินการลงในคิว) และการดำเนินการทั้งหมดจะเสมอ - isReady == ใช่เมื่อถึงเวลาที่พวกเขาใส่ในคิวการดำเนินการดังนั้น NSOperationQueue แบบอนุกรมคือ FIFO

กรอบ Chris Kane Cocoa, Apple

ในกรณีของฉันเป็นไปได้ที่จะทราบเมื่อมีการเพิ่มการดำเนินการล่าสุดลงในคิว ดังนั้นหลังจากเพิ่มการดำเนินการล่าสุดฉันจึงเพิ่มการดำเนินการอื่นในคิวที่มีลำดับความสำคัญต่ำกว่าซึ่งไม่ได้ทำอะไรเลยนอกจากส่งการแจ้งเตือนว่าคิวว่าง จากคำชี้แจงของ Apple สิ่งนี้ทำให้มั่นใจได้ว่าจะมีการส่งหนังสือแจ้งเพียงครั้งเดียวหลังจากการดำเนินการทั้งหมดเสร็จสิ้น

หากมีการเพิ่มการดำเนินการในลักษณะที่ไม่อนุญาตให้ตรวจจับการดำเนินการสุดท้าย (เช่นไม่กำหนดปัจจัย) ฉันคิดว่าคุณต้องใช้แนวทาง KVO ที่กล่าวถึงข้างต้นโดยเพิ่มตรรกะการป้องกันเพิ่มเติมเพื่อพยายามตรวจจับว่าเพิ่มเติม อาจมีการเพิ่มการดำเนินการ

:)

วิธีการเพิ่ม NSOperation ที่ขึ้นอยู่กับคนอื่น ๆ ทั้งหมดเพื่อให้ทำงานได้นาน?

ทางเลือกหนึ่งคือการใช้ GCD อ้างถึงสิ่งนี้เป็นข้อมูลอ้างอิง

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

นี่คือวิธีที่ฉันทำ

ตั้งค่าคิวและลงทะเบียนสำหรับการเปลี่ยนแปลงในคุณสมบัติการดำเนินงาน:

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

... และผู้สังเกตการณ์ (ในกรณีนี้self) ใช้:

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

ในตัวอย่างนี้ "สปินเนอร์" เป็นการUIActivityIndicatorViewแสดงให้เห็นว่ามีบางสิ่งเกิดขึ้น เห็นได้ชัดว่าคุณสามารถเปลี่ยนให้เหมาะกับ ...

ในฐานะของiOS 13.0ที่operationCountและการดำเนินงานคุณสมบัติจะเลิก เพียงแค่ติดตามจำนวนการดำเนินการในคิวของคุณด้วยตัวคุณเองและปิดการแจ้งเตือนเมื่อดำเนินการเสร็จสิ้น ตัวอย่างนี้ใช้ได้กับคลาสย่อยของการทำงานแบบอะซิงโครนัสด้วย

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

ด้านล่างนี้เป็นคลาสย่อยของการดำเนินการสำหรับการดำเนินการแบบอะซิงโครนัสที่ง่าย

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

}

ฉันใช้หมวดหมู่เพื่อทำสิ่งนี้

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 + เสร็จม

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

การใช้งาน :

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

ที่มา: https://gist.github.com/artemstepanenko/7620471

สิ่งที่เกี่ยวกับการใช้ KVO เพื่อสังเกตoperationCountคุณสมบัติของคิว? จากนั้นคุณจะได้ยินเกี่ยวกับเรื่องนี้เมื่อคิวว่างเปล่าและเมื่อคิวว่างเปล่า การจัดการกับตัวบ่งชี้ความคืบหน้าอาจทำได้ง่ายเพียงแค่ทำสิ่งต่อไปนี้

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

เพิ่มการดำเนินการสุดท้ายเช่น:

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

ดังนั้น:

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

}

ด้วยReactiveObjCฉันพบว่ามันใช้งานได้ดี:

// 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, คุณสามารถบรรลุนี้กับ GCD dispatch_groupในรวดเร็ว 3 คุณสามารถรับการแจ้งเตือนเมื่องานทั้งหมดเสร็จสิ้น

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

คุณสามารถสร้างใหม่NSThreadหรือเรียกใช้ตัวเลือกในพื้นหลังและรอที่นั่น เมื่อNSOperationQueueเสร็จสิ้นคุณสามารถส่งการแจ้งเตือนของคุณเอง

ฉันกำลังคิดบางอย่างเช่น:

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

...

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

หากคุณใช้Operationนี้เป็นคลาสพื้นฐานของคุณคุณสามารถส่งต่อwhenEmpty {}บล็อกไปยังOperationQueue :

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

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

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

ไม่มี 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)
    }
}

ถ้าคุณมาที่นี่กำลังมองหาวิธีแก้ปัญหาด้วยการรวม - ฉันก็แค่ฟังวัตถุสถานะของฉันเอง

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

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