Question

我正在使用类似的东西向队列中添加操作

NSInvocationOperation *operation0 = [[NSInvocationOperation alloc] 
initWithTarget:self
selector:@selector(doStuff1) 
object:nil];

[queue addOperation:operation0];
[operation0 release];   


NSInvocationOperation *operation1 = [[NSInvocationOperation alloc] 
initWithTarget:self
selector:@selector(doStuff2) 
object:nil];

[queue addOperation:operation1];
[operation1 release];   


NSInvocationOperation *operation2 = [[NSInvocationOperation alloc] 
initWithTarget:self
selector:@selector(doStuff3) 
object:nil];

[queue addOperation:operation2];
[operation2 release];

队列设置为一次只执行一个操作。所以它会毫不拖延地一个接一个地运行3种方法。这是一种添加一个小延迟的方法，比如说每次操作之间的0.5秒或者其他什么，所以不要运行

doStuff1
doStuff2
doStuff3

队列会做

doStuff1
sleep for X seconds
doStuff2
sleep for X seconds
doStuff3

？

感谢。

Answer 1

使用睡眠是一个很大的浪费。在捉鬼敢死队的意义上这是不好的。

如果您需要一个非并发执行其操作的队列，即顺序执行，您可以简单地将其maxConcurrentOperationCount变量设置为1.

queue.maxConcurrentOperationCount = 1;

要在操作之间暂停，您可以做两件事：

a）延迟每个操作的排队：

//loop over the operations to be queued with and index
      double delayInSeconds = 2.0 * index;
        dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
        dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
            queue.addOperation(operation at index); 
        });

这将排除所有操作而不会阻塞。

b）每项操作都必须实施

- (BOOL)isFinished

你可能已经知道了。

如果您的操作“完成”，只需按照所需的延迟延迟设置“完成”变量。使用类似的东西：

// Operation is done with its work, but we tell the Queue only after 2 seconds, so the queue will start the next operation later
double delayInSeconds = 2.0;
    dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC));
 __weak __typeof(self)weakSelf = self;
    dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
[weakSelf willChangeValueForKey:@"isExecuting"];
    [weakSelf willChangeValueForKey:@"isFinished"];
    weakSelf.executing = NO;
    weakSelf.finished  = YES;
    [weakSelf didChangeValueForKey:@"isFinished"];
    [weakSelf didChangeValueForKey:@"isExecuting"];
    });

变体a）保证操作开始时间之间的暂停。变体b）保证操作结束和下一个操作开始之间的暂停。

Answer 2

如果没有额外的代码，您无法保证NSOperations将以串行方式运行 - 如果Apple发布多处理器iOS设备，它将并行运行多个操作。首先，您应该在操作之间设置依赖关系链。我建议您使用NSOperation - (void)addDependency:(NSOperation *)operation来实现这一目标。你也可以推出自己的花式锁定代码......

然后，您可以在每个doStuff方法的末尾添加sleep（5）。如果您需要在doStuff方法之外进行休眠，请创建一个睡眠NSOperation：

- (void)sleepOperationBody; {
sleep(0.5f);
}

NSInvocationOperation *operation1 = [[NSInvocationOperation alloc] 
initWithTarget:self
selector:@selector(sleepOperationBody) 
object:nil];

那就是说，如果不更详细地了解你需要发生什么，我想你或许只需要一个结合了所有三个任务并在它们之间休眠的NSOperation。那当然是更简单的代码。

Answer 3

我有两种方法可以做这件事。

首先：让当前线程在doStuff1，doStuff2和doStuff3的尾部休眠。

第二：子类NSOperation并覆盖方法 - （void）main。您可以使用目标和操作等参数初始化自定义NSOperation，如下所示：

-(id)initWithTarget:(id)target action:(SEL)action;

通过

在 - （void）main中执行target的此操作

[target performSelector:action];
[NSThread sleepForTimeInterval:0.05];

Answer 4

你可以采取以下方式

[operation0 addDependancy:operation1];
[operation1 addDependancy:operation2];

现在在每个任务结束时添加[NSThread sleepforTimeInterval：5]

iPhone - 队列中的操作之间的延迟

4 个答案: