Ios NSOperationQueue完成块成功时添加新操作_Ios_Objective C_Grand Central Dispatch_Nsoperationqueue

Ios NSOperationQueue完成块成功时添加新操作

ios objective-c

Ios NSOperationQueue完成块成功时添加新操作,ios,objective-c,grand-central-dispatch,nsoperationqueue,Ios,Objective C,Grand Central Dispatch,Nsoperationqueue,我试图在后台线程上以串行顺序完成一些操作我正在调用的函数已经有一个完成块，因此当函数完成时，我想用一个新参数调用同一个函数所以基本上是连续的操作 dispatch\u async或dispatch\u QUEUE\u SERIAL，以正确的顺序启动函数，但在调用下一个函数之前不关心第一个函数是否完成，因此我不想使用它们 NSOperationQueue*serialQ=[[NSOperationQueue alloc]init]； serialQ.maxConcurrentOperation

我试图在后台线程上以串行顺序完成一些操作

我正在调用的函数已经有一个完成块，因此当函数完成时，我想用一个新参数调用同一个函数

所以基本上是连续的操作

dispatch\u async

或

dispatch\u QUEUE\u SERIAL

，以正确的顺序启动函数，但在调用下一个函数之前不关心第一个函数是否完成，因此我不想使用它们

NSOperationQueue*serialQ=[[NSOperationQueue alloc]init]；
serialQ.maxConcurrentOperationCount=1对我来说更有意义。因此，当第一个函数开始计算时，队列上的第二个函数必须等到它完成其完成块
NSOperationQueue* serialQ = [[NSOperationQueue alloc] init];
    serialQ.maxConcurrentOperationCount = 1; //this will set this queue to Serial



        for (File *file in queueArrray) {
            Streamer *streamer=[[Streamer alloc] init];

            NSBlockOperation *downloadOperation = [[NSBlockOperation alloc] init];

            __weak NSBlockOperation *weakDownloadOperation = downloadOperation;

            [weakDownloadOperation addExecutionBlock:^{
                [streamer loadFile:file withCallback:^(NSString *error, BOOL success) {
                    if (success) {
                        NSLog(@"file loaded %@",file.fileUrl);
                        //here start the next operation !!!!!!!!
                        ??????????????????????????????????????
                    }
                }];
            }];  
        }

您的目标方法是异步的。这意味着您不能使用普通块操作，您需要创建一个自定义操作子类，以便在异步方法完成之前操作不会完成
在google上搜索创建异步操作子类的示例，因为您需要组织一些事情
或者，您可以有一个类似于文件数组（或任何东西）的东西，每次异步方法完成时，检查是否有任何内容，删除第一项并对其进行处理。这将一直持续到数组为空…
您的目标方法是异步的。这意味着您不能使用普通块操作，您需要创建一个自定义操作子类，以便在异步方法完成之前操作不会完成
在google上搜索创建异步操作子类的示例，因为您需要组织一些事情
或者，您可以有一个类似于文件数组（或任何东西）的东西，每次异步方法完成时，检查是否有任何内容，删除第一项并对其进行处理。这将一直持续到数组为空…
串行队列事实确保添加到队列中要执行的第一个块在第二个块执行之前完成
-(void)testSerialQueue
{
    dispatch_queue_t serialQueue = dispatch_queue_create("com.serial.queue", DISPATCH_QUEUE_SERIAL);

    dispatch_async(serialQueue, ^{
        [self countTo100];
    });

    dispatch_async(serialQueue, ^{
        [self countFrom200To400];
    });

    dispatch_async(serialQueue, ^{
        [self countFrom400To500];
    });

}

- (void)countTo100
{
    for (int i = 0; i < 100; i++) {
        NSLog(@"%d", i);
    }
}

- (void)countFrom200To400
{
    for (int i = 200; i < 400; i++) {
        NSLog(@"%d", i);
    }
}

- (void)countFrom400To500
{
    for (int i = 400; i < 500; i++) {
        NSLog(@"%d", i);
    }
}

-（void）testSerialQueue
{
dispatch\u queue\u t serialQueue=dispatch\u queue\u create（“com.serial.queue”，dispatch\u queue\u serial）；
调度异步（串行队列^{
[自我计数100]；
});
调度异步（串行队列^{
[自计数从200到400]；
});
调度异步（串行队列^{
[自我计数从400到500]；
});
}
-（无效）计数100
{
对于（int i=0；i<100；i++）{
NSLog（@“%d”，i）；
}
}
-（无效）计数从200到400
{
对于（int i=200；i<400；i++）{
NSLog（@“%d”，i）；
}
}
-（无效）计数从400到500
{
对于（int i=400；i<500；i++）{
NSLog（@“%d”，i）；
}
}

如果从上面查看日志，它将从0连续打印。。先100，然后200。。400和400。。五百
现在，考虑下面的代码段，在其中执行一个并发块内的每个方法，例如，
-(void)testSerialQueue
{
    dispatch_queue_t serialQueue = dispatch_queue_create("com.serial.queue", DISPATCH_QUEUE_SERIAL);

    dispatch_async(serialQueue, ^{
        [self countTo100];
    });

    dispatch_async(serialQueue, ^{
        [self countFrom200To400];
    });

    dispatch_async(serialQueue, ^{
        [self countFrom400To500];
    });

}

- (void)countTo100
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_async(concurrentQueue, ^{
        for (int i = 0; i < 100; i++) {
            NSLog(@"%d", i);
        }
    });

}

- (void)countFrom200To400
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_async(concurrentQueue, ^{
        for (int i = 200; i < 400; i++) {
            NSLog(@"%d", i);
        }
    });
}

- (void)countFrom400To500
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_async(concurrentQueue, ^{
        for (int i = 400; i < 500; i++) {
            NSLog(@"%d", i);
        }
    });
}

-（void）testSerialQueue
{
dispatch\u queue\u t serialQueue=dispatch\u queue\u create（“com.serial.queue”，dispatch\u queue\u serial）；
调度异步（串行队列^{
[自我计数100]；
});
调度异步（串行队列^{
[自计数从200到400]；
});
调度异步（串行队列^{
[自我计数从400到500]；
});
}
-（无效）计数100
{
dispatch\u queue\u t concurrentQueue=dispatch\u get\u global\u queue（dispatch\u queue\u PRIORITY\u DEFAULT，0）；
调度异步（concurrentQueue^{
对于（int i=0；i<100；i++）{
NSLog（@“%d”，i）；
}
});
}
-（无效）计数从200到400
{
dispatch\u queue\u t concurrentQueue=dispatch\u get\u global\u queue（dispatch\u queue\u PRIORITY\u DEFAULT，0）；
调度异步（concurrentQueue^{
对于（int i=200；i<400；i++）{
NSLog（@“%d”，i）；
}
});
}
-（无效）计数从400到500
{
dispatch\u queue\u t concurrentQueue=dispatch\u get\u global\u queue（dispatch\u queue\u PRIORITY\u DEFAULT，0）；
调度异步（concurrentQueue^{
对于（int i=400；i<500；i++）{
NSLog（@“%d”，i）；
}
});
}

在这里，您添加了串行队列中的所有方法，但该方法本身在并发块中运行。因此，在这种情况下，结果是随机的。您还可以像这样使用dispatch_group序列化
-(void)testSerialQueue
{
    dispatch_queue_t serialQueue = dispatch_queue_create("com.serial.queue", DISPATCH_QUEUE_SERIAL);

    self.group = dispatch_group_create();

    dispatch_async(serialQueue, ^{
        [self countTo100];
    });

    dispatch_async(serialQueue, ^{
        [self countFrom200To400];

    });

    dispatch_async(serialQueue, ^{
        [self countFrom400To500];
    });
}

- (void)countTo100
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(self.group);

    dispatch_async(concurrentQueue, ^{
        for (int i = 0; i < 100; i++) {
            NSLog(@"%d", i);
        }
        dispatch_group_leave(self.group);
    });
    dispatch_group_wait(self.group, DISPATCH_TIME_FOREVER);
}

- (void)countFrom200To400
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(self.group);

    dispatch_async(concurrentQueue, ^{
        for (int i = 200; i < 400; i++) {
            NSLog(@"%d", i);
        }
        dispatch_group_leave(self.group);
    });
    dispatch_group_wait(self.group, DISPATCH_TIME_FOREVER);

}

- (void)countFrom400To500
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(self.group);

    dispatch_async(concurrentQueue, ^{
        for (int i = 400; i < 500; i++) {
            NSLog(@"%d", i);
        }
        dispatch_group_leave(self.group);

    });
    dispatch_group_wait(self.group, DISPATCH_TIME_FOREVER);

}

-(void)testSerialQueue
{
    self.group = dispatch_group_create();

    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    queue.maxConcurrentOperationCount = 1;


    NSArray *selectors = @[@"countTo100", @"countFrom200To400", @"countFrom400To500"];

    for (NSString *selector in selectors) {
        NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self
                                                                                selector:NSSelectorFromString(selector)
                                                                                  object:nil];
        [queue addOperation:operation];
    }

}

- (void)countTo100
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(self.group);

    dispatch_async(concurrentQueue, ^{
        for (int i = 0; i < 100; i++) {
            NSLog(@"%d", i);
        }
        dispatch_group_leave(self.group);
    });
    dispatch_group_wait(self.group, DISPATCH_TIME_FOREVER);
}

- (void)countFrom200To400
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(self.group);

    dispatch_async(concurrentQueue, ^{
        for (int i = 200; i < 400; i++) {
            NSLog(@"%d", i);
        }
        dispatch_group_leave(self.group);
    });
    dispatch_group_wait(self.group, DISPATCH_TIME_FOREVER);

}

- (void)countFrom400To500
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(self.group);

    dispatch_async(concurrentQueue, ^{
        for (int i = 400; i < 500; i++) {
            NSLog(@"%d", i);
        }
        dispatch_group_leave(self.group);

    });
    dispatch_group_wait(self.group, DISPATCH_TIME_FOREVER);

}

-（void）testSerialQueue
{
dispatch\u queue\u t serialQueue=dispatch\u queue\u create（“com.serial.queue”，dispatch\u queue\u serial）；
self.group=dispatch_group_create（）；
调度异步（串行队列^{
[自我计数100]；
});
调度异步（串行队列^{
[自计数从200到400]；
});
调度异步（串行队列^{
[自我计数从400到500]；
});
}
-（无效）计数100
{
dispatch\u queue\u t concurrentQueue=dispatch\u get\u global\u queue（dispatch\u queue\u PRIORITY\u DEFAULT，0）；
调度组输入（self.group）；
调度异步（concurrentQueue^{
对于（int i=0；i<100；i++）{
NSLog（@“%d”，i）；
}
派遣组休假（自组）；
});
调度组等待（self.group，调度时间永远）；
}
-（无效）计数从200到400
{
dispatch\u queue\u t concurrentQueue=dispatch\u get\u global\u queue（dispatch\u queue\u PRIORITY\u DEFAULT，0）；
调度组输入（self.group）；
调度异步（concurrentQueue^{
对于（int i=200；i<400；i++）{
NSLog（@“%d”，i）；
}
派遣组休假（自组）；
});
调度组等待（self.group，调度时间永远）；
}
-（无效）计数从400到500
{
dispatch\u queue\u t concurrentQueue=dispatch\u get\u global\u queue（dispatch\u queue\u PRIORITY\u DEFAULT，0）；
调度组输入（self.group）；
调度异步（concurrentQueue^{
对于（int i=400；i<500；i++）{
NSLog（@“%d”，i）；
}
派遣组休假（自组）；
});
调度组等待（self.group，调度时间）
-(void)testSerialQueue
{
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    queue.maxConcurrentOperationCount = 1;

    NSBlockOperation *operation1 = [[NSBlockOperation alloc] init];
    NSBlockOperation *operation2 = [[NSBlockOperation alloc] init];
    NSBlockOperation *operation3 = [[NSBlockOperation alloc] init];

    [operation1 addExecutionBlock:^{
        [self countTo100];
    }];

    [operation2 addExecutionBlock:^{
        [self countFrom200To400];
    }];

    [operation3 addExecutionBlock:^{
        [self countFrom400To500];
    }];        
}

- (void)countTo100
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_async(concurrentQueue, ^{
        for (int i = 0; i < 100; i++) {
            NSLog(@"%d", i);
        }
    });

}

- (void)countFrom200To400
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_async(concurrentQueue, ^{
        for (int i = 200; i < 400; i++) {
            NSLog(@"%d", i);
        }
    });
}

- (void)countFrom400To500
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_async(concurrentQueue, ^{
        for (int i = 400; i < 500; i++) {
            NSLog(@"%d", i);
        }
    });
}

-(void)testSerialQueue
{
    self.group = dispatch_group_create();

    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    queue.maxConcurrentOperationCount = 1;

    NSBlockOperation *operation1 = [[NSBlockOperation alloc] init];
    NSBlockOperation *operation2 = [[NSBlockOperation alloc] init];
    NSBlockOperation *operation3 = [[NSBlockOperation alloc] init];

    [operation1 addExecutionBlock:^{
        [self countTo100];
    }];

    [operation2 addExecutionBlock:^{
        [self countFrom200To400];
    }];

    [operation3 addExecutionBlock:^{
        [self countFrom400To500];
    }];        
}

- (void)countTo100
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(self.group);

    dispatch_async(concurrentQueue, ^{
        for (int i = 0; i < 100; i++) {
            NSLog(@"%d", i);
        }
        dispatch_group_leave(self.group);
    });
    dispatch_group_wait(self.group, DISPATCH_TIME_FOREVER);
}

- (void)countFrom200To400
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(self.group);

    dispatch_async(concurrentQueue, ^{
        for (int i = 200; i < 400; i++) {
            NSLog(@"%d", i);
        }
        dispatch_group_leave(self.group);
    });
    dispatch_group_wait(self.group, DISPATCH_TIME_FOREVER);

}

- (void)countFrom400To500
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(self.group);

    dispatch_async(concurrentQueue, ^{
        for (int i = 400; i < 500; i++) {
            NSLog(@"%d", i);
        }
        dispatch_group_leave(self.group);

    });
    dispatch_group_wait(self.group, DISPATCH_TIME_FOREVER);

}

-(void)testSerialQueue
{
    self.group = dispatch_group_create();

    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    queue.maxConcurrentOperationCount = 1;


    NSArray *selectors = @[@"countTo100", @"countFrom200To400", @"countFrom400To500"];

    for (NSString *selector in selectors) {
        NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self
                                                                                selector:NSSelectorFromString(selector)
                                                                                  object:nil];
        [queue addOperation:operation];
    }

}

- (void)countTo100
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(self.group);

    dispatch_async(concurrentQueue, ^{
        for (int i = 0; i < 100; i++) {
            NSLog(@"%d", i);
        }
        dispatch_group_leave(self.group);
    });
    dispatch_group_wait(self.group, DISPATCH_TIME_FOREVER);
}

- (void)countFrom200To400
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(self.group);

    dispatch_async(concurrentQueue, ^{
        for (int i = 200; i < 400; i++) {
            NSLog(@"%d", i);
        }
        dispatch_group_leave(self.group);
    });
    dispatch_group_wait(self.group, DISPATCH_TIME_FOREVER);

}

- (void)countFrom400To500
{
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(self.group);

    dispatch_async(concurrentQueue, ^{
        for (int i = 400; i < 500; i++) {
            NSLog(@"%d", i);
        }
        dispatch_group_leave(self.group);

    });
    dispatch_group_wait(self.group, DISPATCH_TIME_FOREVER);

}