我有一个应用程序，其中一个长时间运行的进程(> 1 分钟)被放置在 NSOperationQueue(队列 A)上。当队列 A 操作运行时，UI 完全响应，完全符合预期。

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

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

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

我的问题分为两部分:

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

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

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

ViewController 是:

//
//  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 问题( link ， link )，但似乎都没有触及我所看到的问题的核心(先发制人)。

我尝试过的其他事情:

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

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

最佳答案

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

为什么不为慢速操作设置 NSOperationQueue 实例，使其在任何给定时间只执行一个操作(即将此队列的 maxConcurrentOperationCount 设置为 1)，或者如果您的操作都是 block ，那么为什么不直接使用 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];
}

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

编辑:

如果您仍然发现默认的 GCD 队列令人窒息，为什么不创建一个 NSOperation 子类来执行 block 而不使用 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];

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

希望对您有所帮助。

关于objective-c - 在一个 NSOperationQueue 上抢占 NSOperation 并将 NSOperation 放置到一个单独的 NSOperationQueue 上？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/13568756/