2

我有一个应用程序，其中一个长时间运行的进程（> 1 分钟）被放置到 NSOperationQueue（队列 A）上。当队列 A 操作运行时，UI 完全响应，正如预期的那样。

但是，我有一种用户可以执行的不同类型的操作，它在完全独立的 NSOperationQueue（队列 B）上运行。

当 UI 事件触发在队列 B 上放置操作时，它必须等到队列 A 上当前执行的操作完成之后。这发生在 iPod Touch (MC544LL) 上。

相反，我希望看到的是，放置在队列 B 上的任何操作都会或多或少地立即开始与队列 A 上的操作并行执行。这是我在模拟器上看到的行为。

我的问题是两个部分：

  • 根据可用文档，我在设备上看到的行为是否符合预期？
  • 使用 NSOperation/NSOperationQueue，我如何使用队列 B 上的新操作抢占队列 A 上当前正在运行的操作？

注意：我可以通过使用队列 A/B 的 GCD 队列来获得我所追求的行为，所以我知道我的设备能够支持我正在尝试做的事情。但是，我真的非常想使用 NSOperationQueue 因为这两个操作都需要取消。

我有一个简单的测试应用程序：

在此处输入图像描述

视图控制器是：

//
//  ViewController.m
//  QueueTest
//

#import "ViewController.h"

@interface ViewController ()

@property (strong, nonatomic) NSOperationQueue *slowQueue;
@property (strong, nonatomic) NSOperationQueue *fastQueue;

@end

@implementation ViewController

-(id)initWithCoder:(NSCoder *)aDecoder
{
    if (self = [super initWithCoder:aDecoder]) {
        self.slowQueue = [[NSOperationQueue alloc] init];
        self.fastQueue = [[NSOperationQueue alloc] init];
    }

    return self;
}

-(void)viewDidLoad
{
    NSLog(@"View loaded on thread %@", [NSThread currentThread]);
}

// Responds to "Slow Op Start" button
- (IBAction)slowOpStartPressed:(id)sender {
    NSBlockOperation *operation = [[NSBlockOperation alloc] init];

    [operation addExecutionBlock:^{
        [self workHard:600];
    }];

    [self.slowQueue addOperation:operation];
}

// Responds to "Fast Op Start" button
- (IBAction)fastOpStart:(id)sender {    
    NSBlockOperation *operation = [[NSBlockOperation alloc] init];

    [operation addExecutionBlock:^{
        NSLog(@"Fast operation on thread %@", [NSThread currentThread]);
    }];

    [self.fastQueue addOperation:operation];
}

-(void)workHard:(NSUInteger)iterations
{
    NSLog(@"SlowOperation start on thread %@", [NSThread currentThread]);

    NSDecimalNumber *result = [[NSDecimalNumber alloc] initWithString:@"0"];

    for (NSUInteger i = 0; i < iterations; i++) {        
        NSDecimalNumber *outer = [[NSDecimalNumber alloc] initWithUnsignedInteger:i];

        for (NSUInteger j = 0; j < iterations; j++) {
            NSDecimalNumber *inner = [[NSDecimalNumber alloc] initWithUnsignedInteger:j];
            NSDecimalNumber *product = [outer decimalNumberByMultiplyingBy:inner];

            result = [result decimalNumberByAdding:product];
        }

        result = [result decimalNumberByAdding:outer];
    }

    NSLog(@"SlowOperation end");
}

@end

我在第一次按下“Slow Op Start”按钮后看到的输出是大约 1 秒后按下“Fast Op Start”按钮：

2012-11-28 07:41:13.051 QueueTest[12558:907] View loaded on thread <NSThread: 0x1d51ec30>{name = (null), num = 1}
2012-11-28 07:41:14.745 QueueTest[12558:1703] SlowOperation start on thread <NSThread: 0x1d55e5f0>{name = (null), num = 3}
2012-11-28 07:41:25.127 QueueTest[12558:1703] SlowOperation end
2012-11-28 07:41:25.913 QueueTest[12558:3907] Fast operation on thread <NSThread: 0x1e36d4c0>{name = (null), num = 4}

如您所见，第二个操作直到第一个操作完成后才开始执行，尽管它们是两个独立的（并且可能是独立的）NSOperationQueues。

我已阅读Apple Concurrency Guide，但找不到任何描述这种情况的内容。我还阅读了有关相关主题（链接、链接）的两个 SO 问题，但似乎都没有触及我所看到的问题的核心（先发制人）。

我尝试过的其他事情：

  • 在每个 NSOperation 上设置 queuePriority
  • 在每个 NSOperation 上设置 queuePriority，同时将两种类型的操作放在同一个队列中
  • 将两个操作放在同一个队列中

此问题经过多次编辑，可能会使某些评论/答案难以理解。

4

1 回答 1

1

我怀疑您遇到的问题是两个操作队列都在底层默认优先级调度队列上执行它们的块。因此，如果在快速操作之前将几个慢速操作排入队列，那么您可能会看到这种行为。

为什么不为慢速操作设置 NSOperationQueue 实例，使其在任何给定时间只执行一个操作（即，将此队列的 maxConcurrentOperationCount 设置为 1），或者如果您的操作都是块，那么为什么不直接使用 GCD 队列呢？例如

static dispatch_queue_t slowOpQueue = NULL;
static dispatch_queue_t fastOpQueue = NULL;

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    slowOpQueue = dispatch_queue_create("Slow Ops Queue", NULL);
    fastOpQueue = dispatch_queue_create("Fast Ops Queue", DISPATCH_QUEUE_CONCURRENT);
});

for (NSUInteger slowOpIndex = 0; slowOpIndex < 5; slowOpIndex++) {
    dispatch_async(slowOpQueue, ^(void) {
        NSLog(@"* Starting slow op %d.", slowOpIndex);
        for (NSUInteger delayLoop = 0; delayLoop < 1000; delayLoop++) {
            putchar('.');
        }

        NSLog(@"* Ending slow op %d.", slowOpIndex);
    });
}

for (NSUInteger fastBlockIndex = 0; fastBlockIndex < 10; fastBlockIndex++) {
    dispatch_async(fastOpQueue, ^(void) {
        NSLog(@"Starting fast op %d.", fastBlockIndex);
        NSLog(@"Ending fast op %d.", fastBlockIndex);
    });
}

至于根据您关于需要操作取消设施等的评论使用 NSOperationQueue ，您可以尝试：

- (void)loadSlowQueue
{
    [self.slowQueue setMaxConcurrentOperationCount:1];
    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"begin slow block 1");

        [self workHard:500];

        NSLog(@"end slow block 1");
    }];

    NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"begin slow block 2");

        [self workHard:500];

        NSLog(@"end slow block 2");
    }];

    [self.slowQueue addOperation:operation];
    [self.slowQueue addOperation:operation2];
}

因为我认为您添加到慢队列上的操作的两个块正在默认队列上并行执行，并阻止您的快速操作被安排。

编辑：

如果您仍然发现默认的 GCD 队列令人窒息，为什么不创建一个 NSOperation 子类来执行块而不使用 GCD 来处理您的慢速操作，这仍然会为您提供不为每个操作创建单独的子类的声明性便利，但是使用常规 NSOperation 的线程模型。例如

#import <Foundation/Foundation.h>

typedef void (^BlockOperation)(NSOperation *containingOperation);

@interface PseudoBlockOperation : NSOperation

- (id)initWithBlock:(BlockOperation)block;
- (void)addBlock:(BlockOperation)block;

@end

然后是实施：

#import "PseudoBlockOperation.h"

@interface PseudoBlockOperation()

@property (nonatomic, strong) NSMutableArray *blocks;

@end

@implementation PseudoBlockOperation

@synthesize blocks;

- (id)init
{
    self = [super init];

    if (self) {
        blocks = [[NSMutableArray alloc] initWithCapacity:1];
    }

    return self;
}

- (id)initWithBlock:(BlockOperation)block
{
    self = [self init];

    if (self) {
        [blocks addObject:[block copy]];
    }

    return self;
}

- (void)main
{
    @autoreleasepool {
        for (BlockOperation block in blocks) {
            block(self);
        }
    }
}

- (void)addBlock:(BlockOperation)block
{
    [blocks addObject:[block copy]];
}

@end

然后在您的代码中，您可以执行以下操作：

PseudoBlockOperation *operation = [[PseudoBlockOperation alloc] init];
[operation addBlock:^(NSOperation *operation) {
    if (!operation.isCancelled) {
        NSLog(@"begin slow block 1");

        [self workHard:500];

        NSLog(@"end slow block 1");
    }
}];

[operation addBlock:^(NSOperation *operation) {
    if (!operation.isCancelled) {
        NSLog(@"begin slow block 2");

        [self workHard:500];

        NSLog(@"end slow block 2");
    }
}];

[self.slowQueue addOperation:operation];

请注意，在此示例中，添加到同一操作的任何块都将按顺序执行而不是同时执行，以同时执行每个块创建一个操作。这比 NSBlockOperation 的优势在于您可以通过更改 BlockOperation 的定义将参数传递到块中 - 这里我传递了包含操作，但您可以传递任何其他需要的上下文。

希望有帮助。

于 2012-11-26T18:30:53.550 回答