NSThread
1、线程创建方法：
// 手动[NSThread start]启动线程，可以拿到线程对象进行详细设置。
[[NSThread alloc] initWithTarget:self selector:@selector(threadRun) object:nil];
// 手动[NSThread start]启动线程，可以拿到线程对象进行详细设置。
[[NSThread alloc] initWithBlock:^{
}];
// 自动启动线程，无法进行更详细设置。
[NSThread detachNewThreadSelector:@selector(threadRun) toTarget:self withObject:nil];
2、线程退出方法：
[NSThread exit];
也可通过停止runloop来退出线程，具体操作参考下面的标准自定义线程。
3、线程间通讯方法：
[self performSelectorOnMainThread:@selector(onDoSomething) withObject:nil waitUntilDone:NO];
[self performSelector:@selector(onDoSomething) onThread:thread withObject:nil waitUntilDone:NO];
4、标准自定义线程：
@interface ThreadedComponent : NSObject
{
NSThread *_thread;
NSCondition *_condition;
}
- (void)start;
- (void)stop;
@end
- (instancetype)init
{
if ((self = [super init])) {
_condition = [[NSCondition alloc] init];
}
return self;
}
- (void)dealloc
{
[self stop];
}
- (void)start
{
if (_thread) {
return;
}
_thread = [[NSThread alloc] initWithTarget:self selector:@selector(threadProc:) object:nil];
[_condition lock];
[_thread start];
[_condition wait];
[_condition unlock];
NSLog(@"thread should have started");
}
- (void)stop
{
if (!_thread) {
return;
}
[_condition lock];
[self performSelector:@selector(_stop) onThread:_thread withObject:nil waitUntilDone:NO];
[_condition wait];
[_condition unlock];
_thread = nil;
NSLog(@"thread should have stopped");
}
#pragma mark Private Helpers
static void DoNothingRunLoopCallback(void *info)
{
}
- (void)threadProc:(id)object
{
@autoreleasepool {
CFRunLoopSourceContext context = {0};
context.perform = DoNothingRunLoopCallback;
CFRunLoopSourceRef source = CFRunLoopSourceCreate(NULL, 0, &context);
CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
[_condition lock];
[_condition signal];
NSLog(@"thread has started");
[_condition unlock];
// Keep processing events until the runloop is stopped.
CFRunLoopRun();
CFRunLoopRemoveSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
CFRelease(source);
[_condition lock];
[_condition signal];
NSLog(@"thread has stopped");
[_condition unlock];
}
}
- (void)_stop
{
CFRunLoopStop(CFRunLoopGetCurrent());
}
GCD：
1、创建队列方法：
串行队列：
dispatch_queue_t queue = dispatch_queue_create("队列名称", DISPATCH_QUEUE_SERIAL);
并行队列：
dispatch_queue_t queue = dispatch_queue_create("队列名称", DISPATCH_QUEUE_CONCURRENT);
2、同步执行：
dispatch_sync(queue, ^{
//耗时任务
});
3、异步执行：
dispatch_async(queue, ^{
//耗时任务
});
4、需要注意不要在主队列中执行主队列同步操作，会造成卡死。
5、延迟执行：
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 2秒后异步执行这里的代码...
//耗时任务
});
6、重复执行：可以采用并行队列和串行队列执行，如果是并行队列，需要注意资源争抢问题。
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(6, queue, ^(size_t index) {
NSLog(@"%zd------%@",index, [NSThread currentThread]);
});
7、通过Group控制依赖
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 执行1个耗时的异步操作
sleep(1);
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 执行1个耗时的异步操作
sleep(1);
});
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
//dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// // 等前面的异步操作都执行完毕后，回到主线程...
// NSLog(@"onGroup 3");
//});
此处需要注意dispatch_group_wait和dispatch_group_notify却别和使用场景。
8、切换队列，将队列中的任务指定到另外队列上执行。
//1.创建目标队列
//dispatch_queue_t targetQueue = dispatch_queue_create("test.target.queue", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t targetQueue = dispatch_queue_create("test.target.queue", DISPATCH_QUEUE_CONCURRENT);
//2.创建3个串行队列
dispatch_queue_t queue1 = dispatch_queue_create("test.1", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t queue2 = dispatch_queue_create("test.2", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t queue3 = dispatch_queue_create("test.3", DISPATCH_QUEUE_SERIAL);
//3.将3个串行队列分别添加到目标队列
dispatch_set_target_queue(queue1, targetQueue);
dispatch_set_target_queue(queue2, targetQueue);
dispatch_set_target_queue(queue3, targetQueue);
dispatch_async(queue1, ^{
NSLog(@"1 in");
[NSThread sleepForTimeInterval:3.f];
NSLog(@"1 out");
});
dispatch_async(queue1, ^{
NSLog(@"1.1");
});
dispatch_async(queue2, ^{
NSLog(@"2 in");
[NSThread sleepForTimeInterval:2.f];
NSLog(@"2 out");
});
dispatch_async(queue2, ^{
NSLog(@"2.1");
});
dispatch_async(queue3, ^{
NSLog(@"3 in");
[NSThread sleepForTimeInterval:1.f];
NSLog(@"3 out");
});
dispatch_async(queue3, ^{
NSLog(@"3.1");
});
9、使用信号量控制任务依赖
dispatch_queue_t queue = dispatch_queue_create("blockGCD", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
dispatch_async(queue, ^{
NSLog(@"step 0");
sleep(2);
dispatch_semaphore_signal(semaphore);
NSLog(@"step 1");
});
NSLog(@"step 2");
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
dispatch_async(queue, ^{
NSLog(@"step 3");
});
NSLog(@"step 4");
});
10、使用栅栏控制任务依赖
dispatch_queue_t queue = dispatch_queue_create("gcd.test", DISPATCH_QUEUE_CONCURRENT);
NSLog(@"onBarrierAsyncConcurrent 11");
dispatch_async(queue, ^{
sleep(1);
NSLog(@"onBarrierAsyncConcurrent 1");
});
NSLog(@"onBarrierAsyncConcurrent 22");
dispatch_async(queue, ^{
NSLog(@"onBarrierAsyncConcurrent 2");
});
NSLog(@"onBarrierAsyncConcurrent 33");
dispatch_barrier_async(queue, ^{
sleep(1);
NSLog(@"onBarrierAsyncConcurrent 3");
});
NSLog(@"onBarrierAsyncConcurrent 44");
dispatch_async(queue, ^{
NSLog(@"onBarrierAsyncConcurrent 4");
});
NSLog(@"onBarrierAsyncConcurrent 55");
dispatch_async(queue, ^{
NSLog(@"onBarrierAsyncConcurrent 5");
});
11、如何同步多个异步操作：直接上代码
-(void)onGroupOption
{
NSLog(@"onGroupOption Begin");
[self function:0];
[self function:1];
NSLog(@"onGroupOption End");
}
-(void)function:(NSInteger)num
{
if (!_queue) {
_queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
}
if (!_group) {
_group = dispatch_group_create();
}
if (!_sem) {
_sem = dispatch_semaphore_create(1);
}
dispatch_async(_queue, ^{
dispatch_semaphore_wait(_sem, DISPATCH_TIME_FOREVER);
//dispatch_group_enter(_group);
[self onFuncWithID:num complete:^(BOOL success) {
dispatch_semaphore_signal(_sem);
//dispatch_group_leave(_group);
}];
});
}
-(void)onFuncWithID:(NSInteger)ID complete:(void(^)(BOOL success))handler
{
dispatch_async(_queue, ^(void){
NSLog(@"onFuncWithID = %ld", (long)ID);
// do actual processing here
for (int i = 0; i<10; i++) {
//NSLog(@"%d", i);
sleep(0.5);
}
dispatch_async(_queue, ^(void){
NSLog(@"可以处理下一个函数了");
handler(YES);
});
});
}
NSOperationQueue：
不能直接实例化NSOperation，只能实例化子类：NSInvocationOperation和NSBlockOperation。
NSInvocationOperation和NSBlockOperation直接start时，NSInvocationOperation和NSBlockOperation在主线程执行，但addExecutionBlock的任务在子线程执行，一般一次addExecutionBlock就会起一个子线程执行，创建多少个线程，取决于系统资源情况。
NSBlockOperation的addExecutionBlock需要在调用start前执行，否则会出现异常，提示：blocks cannot be added after the operation has started executing or finished。
当NSInvocationOperation和NSBlockOperation调用start后，不能将其再addOperation到队列，否则会出现异常，提示：operation is finished and cannot be enqueued。
NSOperationQueue是异步队列，默认并发数为无穷，可以手动修改并发数量。当并发数设置为1时为串行队列，但其队列中的任务未必会在同一个线程中执行，串行之能保证同一时刻只有一个任务在执行。
任务加入到NSOperationQueue后会自动执行，不用调用start。
可以取消NSOperationQueue未执行的任务，可以暂停NSOperationQueue未执行的任务，可以恢复NSOperationQueue暂停的任务，任务一旦执行，将不能取消和暂停。
可以设置任务之间的依赖来控制任务的执行顺序。
