OC 多线程：NSThread，GCD，NSOperation

OC 常用的多线程实现方法有：

NSThread
GCD
NSOperation

下面逐一总结一下。

NSThread

NSThread是官方提供的，面向对象的创建多线程的方法。

NSThread可以随时查看当前代码所在的线程。比如：

NSLog(@"%@", [NSThread currentThread]);
// <NSThread: 0x6000007f0000>{number = 1, name = main}

NSThread可以使用类方法快速创建子线程，但是得不到子线程对象，线程自动开启。比如：

[NSThread detachNewThreadWithBlock:^{
  NSLog(@"%@", [NSThread currentThread]);
  // <NSThread: 0x60000288a9c0>{number = 7, name = (null)}
}];

NSThread可以使用对象方法创建子线程，能够得到子线程对象，需要调用start方法手动开启子线程。

self.thread = [[NSThread alloc] initWithBlock: ^{
  NSLog(@"%@", [NSThread currentThread]);
  // <NSThread: 0x60000031d980>{number = 7, name = my thread}
}];
self.thread.name = @"my thread";
[self.thread start];

NSThread可以结束子线程、可以随时查看线程的状态（正在执行、被取消、结束）。

self.thread = [[NSThread alloc] initWithBlock: ^{
  NSLog(@"当前线程%@", [NSThread currentThread]);
  NSLog(@"isExecuting=%d", self.thread.isExecuting);
  NSLog(@"isCancelled=%d", self.thread.isCancelled);
  NSLog(@"isFinished=%d", self.thread.isFinished);
  for (int i = 0; i < 100; i++) {
    NSLog(@"i = %d", i);
    if (i == 6) {
      NSLog(@"结束线程%@", [NSThread currentThread]);
      //结束线程
      [NSThread exit];
      NSLog(@"这行代码不会打印的");
    }
  }
}];

self.thread.name = @"my thread";

[self.thread start];

[NSThread sleepForTimeInterval:2];

NSLog(@"isExecuting=%d", self.thread.isExecuting);
NSLog(@"isCancelled=%d", self.thread.isCancelled);
NSLog(@"isFinished=%d", self.thread.isFinished);

// 当前线程<NSThread: 0x6000003ed740>{number = 7, name = my thread}
// isExecuting=1
// isCancelled=0
// isFinished=0
// i = 0
// i = 1
// i = 2
// i = 3
// i = 4
// i = 5
// i = 6
// 结束线程<NSThread: 0x6000003ed740>{number = 7, name = my thread}
// isExecuting=0
// isCancelled=0
// isFinished=1

我们可以看到，exit方法可以终止线程的执行，执行exit方法可以把isExecuting从1设为0，把isFinished从0设为1，而isCancelled不受影响，这说明cancel只是一个属性，并不能真正的取消当前线程。

GCD

GCD（Grand Central Dispatch）是苹果官方开发的解决多线程的一种方案。GCD引入了两个核心概念，任务和队列，来抽象多线程的创建和调用。理解任务和队列是正确使用GCD的关键。

任务又分为同步任务（sync）和异步任务（async）：

同步任务：把任务添加到当前线程中，不开启新的线程，在任务完成之前阻塞当前线程，都是串行执行任务
异步任务：可以开启新的线程，任务可以添加到新的线程中，不阻塞当前线程

队列又分为串行队列（serial）和并发队列（concurrent）：

串行队列：在一个线程中，一个接一个的完成任务，先进先出（FIFO）
并发队列：在一个或多个线程中，并发的完成任务（后添加的任务不用等待前添加的任务先完成）

基于以上分类，我们可以得出一些推论：

并发队列只有在异步任务中才有效，因为在同步任务中，不能开启新线程，并发队列还是只能一个接一个的完成，这就相当于串行队列

开发中常用的队列有四种，分别是：

自定义串行队列：当前线程中建立的串行队列，在当前线程中，dispatch_queue_create("CXqueue", DISPATCH_QUEUE_SERIAL);
自定义并发队列：当前线程中建立的并发队列，因为是并发，所以可以在任意线程，dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
全局队列：全局中的并发队列，因为是并发，所以可以在任意线程，dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
主队列：主线程中的主队列，是串行队列，dispatch_get_main_queue()

这里可以看出，自定义并发队列和全局队列的作用很相似。

下面讨论一下不同任务和队列和组合：

同步任务+自定义串行队列
同步任务+自定义并发队列
异步任务+自定义串行队列
异步任务+自定义并发队列
同步任务+主队列
异步任务+主队列
同步任务+全局队列
异步任务+全局队列

同步任务+自定义串行队列：

dispatch_queue_t q = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);

NSLog(@"开始");
dispatch_sync(q, ^{
  NSLog(@"任务一");
  NSLog(@"当前线程：%@",[NSThread currentThread]);
});
dispatch_sync(q, ^{
  [NSThread sleepForTimeInterval:2.0];
  NSLog(@"任务二，睡了2秒");
  NSLog(@"当前线程：%@",[NSThread currentThread]);
});
dispatch_sync(q, ^{
  NSLog(@"任务三");
  NSLog(@"当前线程：%@",[NSThread currentThread]);
});
NSLog(@"结束");

// 开始
// 任务一
// 当前线程：<NSThread: 0x6000039dc100>{number = 1, name = main}
// 任务二，睡了2秒
// 当前线程：<NSThread: 0x6000039dc100>{number = 1, name = main}
// 任务三
// 当前线程：<NSThread: 0x6000039dc100>{number = 1, name = main}
// 结束

可以看到，任务一，二，三，一个接一个的完成了，而且都在线程1中（主线程main）。

同步任务+自定义并行队列：

dispatch_queue_t q = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);

NSLog(@"开始");
dispatch_sync(q, ^{
    NSLog(@"任务一");
    NSLog(@"当前线程：%@",[NSThread currentThread]);
});
dispatch_sync(q, ^{
    [NSThread sleepForTimeInterval:2.0];
    NSLog(@"任务二，睡了2秒");
    NSLog(@"当前线程：%@",[NSThread currentThread]);
});
dispatch_sync(q, ^{
    NSLog(@"任务三");
    NSLog(@"当前线程：%@",[NSThread currentThread]);
});
NSLog(@"结束");

// 开始
// 任务一
// 当前线程：<NSThread: 0x600000380980>{number = 1, name = main}
// 任务二，睡了2秒
// 当前线程：<NSThread: 0x600000380980>{number = 1, name = main}
// 任务三
// 当前线程：<NSThread: 0x600000380980>{number = 1, name = main}
// 结束

可以看到，任务一，二，三，一个接一个的完成了，而且都在线程1中，这说明并发队列在同步任务中相当于串行队列。

异步任务+自定义串行队列：

dispatch_queue_t q = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);

NSLog(@"当前线程：%@", [NSThread currentThread]);

NSLog(@"开始");
dispatch_async(q, ^{
    NSLog(@"任务一");
    NSLog(@"当前线程：%@",[NSThread currentThread]);
});
dispatch_async(q, ^{
    [NSThread sleepForTimeInterval:2.0];
    NSLog(@"任务二，睡了2秒");
    NSLog(@"当前线程：%@",[NSThread currentThread]);
});
dispatch_async(q, ^{
    NSLog(@"任务三");
    NSLog(@"当前线程：%@",[NSThread currentThread]);
});
NSLog(@"结束");

// 当前线程：<NSThread: 0x60000357c000>{number = 1, name = main}
// 开始
// 结束
// 任务一
// 当前线程：<NSThread: 0x600003545c40>{number = 6, name = (null)}
// 任务二，睡了2秒
// 当前线程：<NSThread: 0x600003545c40>{number = 6, name = (null)}
// 任务三
// 当前线程：<NSThread: 0x600003545c40>{number = 6, name = (null)}

可以看到，任务一，二，三是一个接一个完成，的确是串行的，但他们都被放到了线程6去执行了，这是因为异步任务的原因，还是就是打印开始之后，马上就是打印结束，这说明异步任务的创建需要时间，异步任务开始前，主线程已经完成打印了

异步任务+自定义并行队列：

dispatch_queue_t q = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);

NSLog(@"当前线程：%@", [NSThread currentThread]);

NSLog(@"开始");
dispatch_async(q, ^{
    NSLog(@"任务一");
    NSLog(@"当前线程：%@",[NSThread currentThread]);
});
dispatch_async(q, ^{
    [NSThread sleepForTimeInterval:2.0];
    NSLog(@"任务二，睡了2秒");
    NSLog(@"当前线程：%@",[NSThread currentThread]);
});
dispatch_async(q, ^{
    NSLog(@"任务三");
    NSLog(@"当前线程：%@",[NSThread currentThread]);
});
NSLog(@"结束");

// 当前线程：<NSThread: 0x600003cd8300>{number = 1, name = main}
// 开始
// 结束
// 任务一
// 任务三
// 当前线程：<NSThread: 0x600003cea3c0>{number = 3, name = (null)}
// 当前线程：<NSThread: 0x600003cc0e40>{number = 6, name = (null)}
// 任务二，睡了2秒
// 当前线程：<NSThread: 0x600003cff880>{number = 5, name = (null)}

可以看到，任务一，二，三并放到了三个不同的线程中去执行，并且执行的时候是并发的（不是一个接一个的完成）

同步任务+主队列（重点来了）

dispatch_queue_t q = dispatch_get_main_queue();

NSLog(@"当前线程：%@", [NSThread currentThread]);

NSLog(@"开始");
dispatch_sync(q, ^{  // Thread 1: EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP, subcode=0x0)
    NSLog(@"任务一");
    NSLog(@"当前线程：%@",[NSThread currentThread]);
});
dispatch_sync(q, ^{
    [NSThread sleepForTimeInterval:2.0];
    NSLog(@"任务二，睡了2秒");
    NSLog(@"当前线程：%@",[NSThread currentThread]);
});
dispatch_sync(q, ^{
    NSLog(@"任务三");
    NSLog(@"当前线程：%@",[NSThread currentThread]);
});
NSLog(@"结束");

奔溃了，原因是发生了死锁，为什么呢？

我们就拿任务一进行分析。

因为在主线程中，dispatch_sync也是一个任务，因为阻塞线程，现在被添加到了主队列，dispatch_sync中的任务（任务一）也添加到了主队列，任务一完成后dispatch_sync才能返回（完成），而按照串行队列的定义，dispatch_sync完成后，任务一才能执行，因此，dispatch_sync与任务一之间创造了死锁。

同样都是串行队列，为什么主队列会死锁，而自定义串行队列不会呢？

因为如果是自定义串行队列，dispatch_sync中的任务（任务一）被添加到自定义的队列中，这样任务一在自定义串行队列中，不用等待dispatch_sync完成才开始执行，自己就执行了，dispatch_sync等任务一完成后，就返回了，所以没有造成死锁。

异步任务+主队列

dispatch_queue_t q = dispatch_get_main_queue();

NSLog(@"当前线程：%@", [NSThread currentThread]);

NSLog(@"开始");
dispatch_async(q, ^{
    NSLog(@"任务一");
    NSLog(@"当前线程：%@",[NSThread currentThread]);
});
dispatch_async(q, ^{
    [NSThread sleepForTimeInterval:2.0];
    NSLog(@"任务二，睡了2秒");
    NSLog(@"当前线程：%@",[NSThread currentThread]);
});
dispatch_async(q, ^{
    NSLog(@"任务三");
    NSLog(@"当前线程：%@",[NSThread currentThread]);
});
NSLog(@"结束");

// 当前线程：<NSThread: 0x6000017e8900>{number = 1, name = main}
// 开始
// 结束
// 任务一
// 当前线程：<NSThread: 0x6000017e8900>{number = 1, name = main}
// 任务二，睡了2秒
// 当前线程：<NSThread: 0x6000017e8900>{number = 1, name = main}
// 任务三
// 当前线程：<NSThread: 0x6000017e8900>{number = 1, name = main}

可以看到，因为是同步任务，任务一，二，三还是按照串行的方式执行的，而且都在主线程中执行，因为dispatch_async不阻塞当前线程（不用等待里面的任务完成之后才返回），所以不造成死锁，同时我们注意到，异步任务没有开启新的线程，这和异步任务+自定义串行队列有区别。

同步任务+全局队列

与同步任务+自定义并行队列结果一样

异步任务+全局队列

与异步任务+自定义并行队列结果一样

总结：

GCD的使用步骤：
1. 创建或者获取队列（串行、并发，主队列，全局队列）
2. 创建任务（同步、异步）
3. 把任务放在队列中执行
同步任务+自定义串行队列：不开启新线程，串行执行
同步任务+自定义并发队列：不开启新线程，串行执行
异步任务+自定义串行队列：开启新线程，串行执行
异步任务+自定义并发队列：开启新线程，并行执行
同步任务+主队列：死锁
异步任务+主队列：不开启新线程，串行执行
同步任务+全局队列：开启新线程，串行执行
异步任务+全局队列：开启新线程，并行执行

NSOperation

NSOperation的使用和GCD类似，也是三步：

将任务封装到NSOperation对象中
将NSOperation对象添加到NSOperationQueue中
系统将NSOperationQueue中的NSOperation中的任务取出来放到一条新线程中执行。

NSOperation是一个抽象类，不具备封装操作的能力，必须使用它的子类，他的子类有：NSInvocationOperation, NSBlockOperation, 或者自定义子类。

NSInvocationOperation可以直接start任务（在主线程）：

- (void)viewDidLoad {
    [super viewDidLoad];
    NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(test) object:nil];
    [operation start];
}

- (void)test {
    NSLog(@"----任务开始----");
    NSLog(@"当前线程：%@", [NSThread currentThread]);
}

// ----任务开始----
// 当前线程：<NSThread: 0x600002f2c3c0>{number = 1, name = main}

NSBlockOperation可以直接start任务（在主线程），还可以追加任务，追加的任务在子线程（是并行的）：

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // NSBlockOperation
    NSBlockOperation * operation = [NSBlockOperation blockOperationWithBlock:^{
        // 要执行的操作，目前是主线程
        NSLog(@"NSBlockOperation 创建，当前线程：%@",[NSThread currentThread]);
    }];
    // 追加任务，在子线程中执行
    [operation addExecutionBlock:^{
        NSLog(@"追加任务一");
        [self test];
    }];
    [operation addExecutionBlock:^{
        NSLog(@"追加任务二, %@",[NSThread currentThread]);
    }];
    [operation start];

}

- (void)test {
    NSLog(@"----任务开始----");
    NSLog(@"当前线程：%@", [NSThread currentThread]);
}

// 追加任务一
// NSBlockOperation 创建，当前线程：<NSThread: 0x600003af4380>{number = 1, name = main}
// 追加任务二, <NSThread: 0x600003aeaa40>{number = 3, name = (null)}
// ----任务开始----
// 当前线程：<NSThread: 0x600003aa9000>{number = 6, name = (null)}

自定义子类：

@interface BZOperation : NSOperation
@end

@implementation BZOperation
-(void) main {
    NSLog(@"我是自定义NSOperation，当前线程：%@", [NSThread currentThread]);
}
@end

BZOperation * operation = [[BZOperation alloc] init];
[operation start];

// 我是自定义NSOperation，当前线程：<NSThread: 0x600002a64440>{number = 1, name = main}

下面总结NSOperationQueue

NSOperationQueue相当于GCD中的队列，将NSOperation加入到NSOperationQueue后，就自动执行NSOperation中的任务了，不需要执行start方法。

主要有两种队列：

主队列：在主队列中的任务都在主线程中执行。
非主队列：非主队列中的任务可以在其他线程中执行。

添加NSOperation到NSOperationQueue的方法主要有两种：

-(void)addOperation:(NSOperation *)op;
-(void)addOperationWithBlock:(void (^)(void))block;

下面我们尝试一下不同的组合：

主队列+NSBlockOperation

//1.创建主队列
NSOperationQueue *q1 = [NSOperationQueue mainQueue];
//2.创建任务
NSBlockOperation *p1 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"任务一，当前线程：%@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:2.0];
    NSLog(@"任务一结束");
}];
NSBlockOperation *p2 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"任务二，当前线程：%@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:2.0];
    NSLog(@"任务二结束");
}];

NSBlockOperation *p3 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"任务三，当前线程：%@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:2.0];
    NSLog(@"任务三结束");
}];

//3.把任务添加到队列
[q1 addOperation:p1];
[q1 addOperation:p2];
[q1 addOperation:p3];

// 任务一，当前线程：<NSThread: 0x60000118c000>{number = 1, name = main}
// 任务一结束
// 任务二，当前线程：<NSThread: 0x60000118c000>{number = 1, name = main}
// 任务二结束
// 任务三，当前线程：<NSThread: 0x60000118c000>{number = 1, name = main}
// 任务三结束

可以看出，任务全都在主线程中串行执行的。

非主队列+NSBlockOperation

//1.创建非主队列
NSOperationQueue *q1 = [[NSOperationQueue alloc] init];
//2.创建任务
NSBlockOperation *p1 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"任务一，当前线程：%@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:2.0];
    NSLog(@"任务一结束");
}];
NSBlockOperation *p2 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"任务二，当前线程：%@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:2.0];
    NSLog(@"任务二结束");
}];

NSBlockOperation *p3 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"任务三，当前线程：%@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:2.0];
    NSLog(@"任务三结束");
}];

//3.把任务添加到队列
[q1 addOperation:p1];
[q1 addOperation:p2];
[q1 addOperation:p3];

// 任务三，当前线程：<NSThread: 0x600001a66d80>{number = 6, name = (null)}
// 任务二，当前线程：<NSThread: 0x600001a55800>{number = 4, name = (null)}
// 任务一，当前线程：<NSThread: 0x600001a5e000>{number = 3, name = (null)}
// 任务二结束
// 任务一结束
// 任务三结束

可以看到，任务是在不同线程中，并发完成的。

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 204,590评论 6赞 478
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 86,808评论 2赞 381
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 151,151评论 0赞 337
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,779评论 1赞 277
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,773评论 5赞 367
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,656评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,022评论 3赞 398
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,678评论 0赞 258
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 41,038评论 1赞 299
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,659评论 2赞 321
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,756评论 1赞 330
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,411评论 4赞 321
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,005评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,973评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,203评论 1赞 260
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,053评论 2赞 350
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,495评论 2赞 343

OC 多线程：NSThread，GCD，NSOperation

NSThread

GCD

NSOperation

推荐阅读更多精彩内容