Nhận thông báo khi NSOperationQueue hoàn thành tất cả các tác vụ

NSOperationQueuecó waitUntilAllOperationsAreFinished, nhưng tôi không muốn đợi đồng bộ cho nó. Tôi chỉ muốn ẩn chỉ báo tiến trình trong giao diện người dùng khi hàng đợi kết thúc.

Cách tốt nhất để thực hiện điều này là gì?

Tôi không thể gửi thông báo từ NSOperations của mình vì tôi không biết thông báo nào sẽ đến cuối cùng và [queue operations]có thể chưa để trống (hoặc tệ hơn - được sắp xếp lại) khi nhận được thông báo.

Sử dụng KVO để quan sát thuộc operationstính của hàng đợi của bạn, sau đó bạn có thể biết liệu hàng đợi của mình đã hoàn thành hay chưa bằng cách kiểm tra [queue.operations count] == 0.

Ở đâu đó trong tệp bạn đang thực hiện KVO, hãy khai báo ngữ cảnh cho KVO như sau ( thông tin thêm ):

static NSString *kQueueOperationsChanged = @"kQueueOperationsChanged";

Khi bạn thiết lập hàng đợi của mình, hãy làm như sau:

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

Sau đó, làm điều này trong 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];
    }
}

(Điều này giả định rằng của bạn NSOperationQueueđang ở trong một sản phẩm có tên queue)

Tại một số thời điểm trước khi đối tượng của bạn hoàn toàn deallocs (hoặc khi nó ngừng quan tâm đến trạng thái hàng đợi), bạn sẽ cần hủy đăng ký khỏi KVO như sau:

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

Phụ lục: iOS 4.0 có một thuộc NSOperationQueue.operationCounttính mà theo tài liệu là tuân thủ KVO. Tuy nhiên, câu trả lời này sẽ vẫn hoạt động trong iOS 4.0, vì vậy nó vẫn hữu ích cho khả năng tương thích ngược.

Nếu bạn đang mong đợi (hoặc mong muốn) điều gì đó phù hợp với hành vi này:

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>

Bạn nên lưu ý rằng nếu một số hoạt động "ngắn" đang được thêm vào hàng đợi, bạn có thể thấy hành vi này thay thế (vì các hoạt động được bắt đầu như một phần của việc được thêm vào hàng đợi):

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>

Trong dự án của mình, tôi cần biết khi nào hoạt động cuối cùng hoàn thành, sau khi một số lượng lớn hoạt động đã được thêm vào NSOperationQueue nối tiếp (tức là, maxConcurrentOperationCount = 1) và chỉ khi tất cả chúng đã hoàn thành.

Googling Tôi đã tìm thấy tuyên bố này từ một nhà phát triển của Apple để trả lời cho câu hỏi "có phải là NSoperationQueue FIFO nối tiếp không?" -

Nếu tất cả các hoạt động có cùng mức ưu tiên (không bị thay đổi sau khi hoạt động được thêm vào hàng đợi) và tất cả các hoạt động luôn - isReady == YES vào thời điểm chúng được đưa vào hàng đợi hoạt động, thì NSOperationQueue nối tiếp là FIFO.

Chris Kane Khung ca cao, Apple

Trong trường hợp của tôi, có thể biết khi nào thao tác cuối cùng được thêm vào hàng đợi. Vì vậy, sau khi thao tác cuối cùng được thêm, tôi thêm một thao tác khác vào hàng đợi, có mức độ ưu tiên thấp hơn, thao tác này không làm gì khác ngoài việc gửi thông báo rằng hàng đợi đã được làm trống. Theo tuyên bố của Apple, điều này đảm bảo rằng chỉ có một thông báo duy nhất được gửi sau khi tất cả các hoạt động đã hoàn thành.

Nếu các hoạt động đang được thêm vào theo cách không cho phép phát hiện cái cuối cùng, (tức là không xác định) thì tôi nghĩ bạn phải thực hiện với các phương pháp KVO được đề cập ở trên, với logic bảo vệ bổ sung được thêm vào để cố gắng phát hiện nếu xa hơn các hoạt động có thể được thêm vào.

:)

Làm thế nào về việc thêm một NSOperation phụ thuộc vào tất cả những người khác để nó chạy lâu dài?

Một thay thế là sử dụng GCD. Tham khảo đây là tài liệu tham khảo.

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

Đây là cách tôi làm điều đó.

Thiết lập hàng đợi và đăng ký các thay đổi trong thuộc tính hoạt động:

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

... và người quan sát (trong trường hợp này self) thực hiện:

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

Trong ví dụ này, "spinner" là UIActivityIndicatorViewcho thấy có điều gì đó đang xảy ra. Rõ ràng là bạn có thể thay đổi để phù hợp với ...

Tôi đang sử dụng một danh mục để làm điều này.

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

Cách sử dụng :

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

Nguồn: https://gist.github.com/artemstepanenko/7620471

Tính đến iOS 13.0 , các operationCount và hoạt động bất động sản đang bị phản đối. Thật đơn giản để tự theo dõi số lượng hoạt động trong hàng đợi của bạn và kích hoạt Thông báo khi tất cả chúng đã hoàn thành. Ví dụ này cũng hoạt động với một lớp con không đồng bộ của Hoạt động .

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

Dưới đây là một lớp con của Hoạt động cho các hoạt động không đồng bộ dễ dàng

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

}

Điều gì về việc sử dụng KVO để quan sát thuộc operationCounttính của hàng đợi? Sau đó, bạn sẽ nghe về nó khi hàng đợi trống, và cả khi hàng không còn trống. Đối phó với chỉ báo tiến trình có thể đơn giản như chỉ làm một cái gì đó như:

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

Thêm thao tác cuối cùng như:

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

Vì thế:

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

}

Với ReactiveObjC, tôi thấy điều này hoạt động tốt:

// 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, Bạn có thể đạt được điều này với GCD dispatch_group trong nhanh chóng 3 . Bạn có thể nhận được thông báo khi tất cả các nhiệm vụ hoàn thành.

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

Bạn có thể tạo mới NSThreadhoặc thực thi một bộ chọn trong nền và đợi ở đó. Khi NSOperationQueuekết thúc, bạn có thể gửi một thông báo của riêng mình.

Tôi đang nghĩ về điều gì đó như:

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

...

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

Nếu bạn sử dụng Thao tác này làm lớp cơ sở của mình, bạn có thể chuyển whenEmpty {}khối cho OperationQueue :

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

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

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

Không có 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)
    }
}

Nếu bạn đến đây để tìm kiếm một giải pháp với kết hợp - tôi đã kết thúc chỉ lắng nghe đối tượng trạng thái của riêng tôi.

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

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