iOS中，只有主线程跟Cocoa关联，也即是在这个线程中，更新UI总是有效的，如果在其他线程中更新UI有时候会成功，但可能失败。所以苹果要求开发者在主线程中更新UI。但是如果我们吧所有的操作都放置在主线程中执行，当遇到比较耗时的操作的时候，势必会阻塞线程，出现界面卡顿的情况。这时候采取将耗时的操作放入后台线程中操作，且保持主线程只更新UI是我们推荐的做法。

在iOS中，要实现多线程，一共有四种方式。  它们分别是：

pthreadsPOSIX线程（POSIX threads），简称Pthreads，是线程的POSIX标准。该标准定义了创建和操纵线程的一整套API。在类Unix操作系统（Unix、Linux、Mac OS X等）中，都使用Pthreads作为操作系统的线程。Windows操作系统也有其移植版pthreads-win32[1]这篇文章不介绍

NSThread需要管理线程的生命周期、同步、加锁问题，这会导致一定的性能开销

NSOperation & NSOperationQueue

GCDiOS4开始，苹果发布了GCD，可以自动对线程进行管理。极大的方便了多线程的开发使用

一、pthread

pthread是一套基于C的API，它不接受cocoa框架的控制：当手动创建pthread的时候，cocoa框架并不知道。 苹果不建议在cocoa中使用pthread，但是如果为了方便不得不使用，我们应该小心的使用。

下面这些方法可以创建pthread

OC

pthread_attr_t qosAttribute;

pthread_attr_init(&qosAttribute);

pthread_attr_set_qos_class_np(&qosAttribute, QOS_CLASS_UTILITY, 0);

pthread_create(&thread, &qosAttribute, f,NULL);

SWIFT

varthread= pthread_t()

var qosAttribute = pthread_attr_t()

pthread_attr_init(&qosAttribute)

pthread_attr_set_qos_class_np(&qosAttribute, QOS_CLASS_UTILITY, 0)

pthread_create(&thread, &qosAttribute, f,nil)

并且，可以使用下面的API对一个pthread进行修改。

苹果的文档中，有一篇文档讲述了GCD中使用pthread的禁忌：Compatibility with POSIX Threads。

6OBJECTIVE-C

pthread_set_qos_class_self_np(QOS_CLASS_BACKGROUND,0);

SWIFT

pthread_set_qos_class_self_np(QOS_CLASS_BACKGROUND, 0)

二、NSThread

对于NSThread，在使用的过程中，我们需要手动完成很多动作才能确保线程的顺利运行。但与此同时，它给我们带来更大的定制化空间。

1.创建NSThread。

对于NSThread的创建，苹果给出了三种使用方式。

detachNewThreadSelector(_:toTarget:with:)   detachNewThreadSelector  会创建一个新的线程，并直接进入线程执行。

initWith(Target:selector:object:)          iOS10.0之前的创建方式，需要手动执行。

initWithBlock                                      iOS10.0之后，可以创建一个执行block的线程。

2.NSThread线程通信。

如果我们想对已经存在的线程进行操作，可以使用

performSelector:onThread:withObject:waitUntilDone:

跳转到目标线程执行，实现线程间跳转，达到线程通信的目的。但是需要注意的是，这个方法不适合频繁的进行通信，尤其是对于一些敏感的操作。

3.NSThread线程的状态。

在一个线程中，可以通过相关的函数获取到它的当前状态。

+ isMainThread：判断当前线程是不是主线程。

+ mainThread：获取当前的主线程。

+ isMultiThreaded ：判断当前环境是不是多线程环境

+ threadDictionary :获取包含项目中的线程的字典

@property(readonly, getter=isExecuting)BOOL executingNS_AVAILABLE(10_5, 2_0);     是否处于运行状态

@property(readonly, getter=isFinished)BOOL finishedNS_AVAILABLE(10_5, 2_0);          是否处于完成状态

@property(readonly, getter=isCancelled)BOOL cancelledNS_AVAILABLE(10_5, 2_0);      是否处于取消状态

4.NSThread线程的优先级。

可通过给NSThread设置优先级。以便让开发者更灵活的控制程序的执行。

+ threadPriority  Returns the currentthread’s priority. 返回当前线程的优先级别

threadPriority        The receiver’s priority  消息发送者的优先级，这个发送者是一个NSThread对象

+ setThreadPriority:     Sets the currentthread’s priority. 设置线程的优先级

5.停止线程／终止线程

+ sleepUntilDate:   Blocks the currentthreaduntil the time specified.  直到某时刻执行

+ sleepForTimeInterval:     Sleeps thethreadfora given time interval.   暂停线程

+ exit    Terminates the currentthread.  关闭线程，这里调用之前，为了确保程序的安全，我们应在明确线程的状态是isFinished 和 isCancelled的时候执行。

- cancel    Changes the cancelled state of the receiver to indicate that it should exit.  主动进入取消状态，如果当时线程没有完成，会继续执行完成。

6.使用NSThread

- (void)viewDidLoad {

[superviewDidLoad];

_testCount = 100;

_t1 =  [[NSThread alloc] initWithTarget:selfselector:@selector(test) object:nil];

_t1.name = @"线程一";

[_t1 start];

NSInvocationOperation

}

-(void)test{

for(inti = 0; i < 5 ; i++) {

[NSThreadsleepForTimeInterval:0.05];

NSLog(@"%ld,%@",(long)_testCount--,[[NSThreadcurrentThread] name]);

}

}

三、NSOperation & NSOperationQueue

1.NSOperation

NSOperation是对于线程对象的抽象封装，不会被直接使用，在日常的开发中，会使用它的两个子类：NSInvocationOperation和NSBlockOperation。NSInvocationOperation类是NSOperation的具体子类，用于管理指定为调用的单个封装任务的执行。 您可以使用此类来启动包含在指定对象上调用选择器的操作。 此类实现非并发操作。NSBlockOperation类也是NSOperation的具体子类，用于管理一个或多个block块的并发执行。 您可以使用此对象一次执行多个block，而无需为每个块创建单独的操作对象。 当执行多个程序段时，只有当所有程序段执行完毕时，才会将操作本身完成。

NSInvocationOperation实现非并发操作。

3_invCationOp = [[NSInvocationOperationalloc] initWithTarget:selfselector:@selector(test2:) object:nil];

_invCationOp.name = @"invocation线程";

[_invCationOp start];

打印：

{number = 1, name = main},

{number = 1, name = main}

从打印结果可以看出，NSInvocationOperation实现的是非并法的操作，至于在哪个线程中操作，取决于start的当前调用时的线程。

如果我们需要创建一个并发的Queue，可以使用NSBlockOperation。如果我们像这样创建：

- (void)blockOperation{

NSBlockOperation*blockOp = [NSBlockOperationblockOperationWithBlock:^{

NSLog(@"%@,%@",[NSThreadcurrentThread],[NSThreadmainThread]);

}];

[blockOp addExecutionBlock:^{

NSLog(@"%@,%@",[NSThreadcurrentThread],[NSThreadmainThread]);

}];

[blockOp addExecutionBlock:^{

NSLog(@"%@,%@",[NSThreadcurrentThread],[NSThreadmainThread]);

}];

[blockOp start];

}

打印：

2017-05-23 15:11:00.289多线程[5377:589808] {number = 1, name = main},{number = 1, name = main}

2017-05-23 15:11:00.289多线程[5377:589808] {number = 1, name = main},{number = 1, name = main}

2017-05-23 15:11:00.289多线程[5377:589808] {number = 1, name = main},{number = 1, name =  main}

显然，这里都在主线程中执行，不能证明NSBlockOperation具有并发的能力，这是因为，每个NSBlockOperation对象的会优先在主线程中执行。如果主线程受到阻塞的时候才会开辟另一个线程去执行其他的操作。比如向下面这样：

//NSBlockOperation

 - (void)blockOperation{

NSBlockOperation*blockOp = [NSBlockOperationblockOperationWithBlock:^{

NSLog(@"%@,%@",[NSThreadcurrentThread],[NSThreadmainThread]);

     }];

     [blockOp addExecutionBlock:^{

         [NSThreadsleepForTimeInterval:2.0];

NSLog(@"%@,%@",[NSThreadcurrentThread],[NSThreadmainThread]);

     }];

     [blockOp addExecutionBlock:^{

         [NSThreadsleepForTimeInterval:2.0];

NSLog(@"%@,%@",[NSThreadcurrentThread],[NSThreadmainThread]);

     }];

     [blockOp start];

 }

打印：

2017-05-23 15:28:37.780多线程[5645:617976] {number = 1, name = main},{number = 1, name = main}

2017-05-23 15:28:39.848多线程[5645:618027] {number = 3, name = (null)},{number = 1, name = (null)}

2017-05-23 15:28:39.848多线程[5645:618028] {number = 4, name = (null)},{number = 1, name = (null)}=

这里就是异步执行了。NSBlockOperation在使用的过程中，会针对主线程当前的使用情况，选择性的创建其他的线程。在提升流畅度的同时，还节约了资源。

2.NSOperationQueue

NSOperationQueue：手动管理异步执行。  如果我们想使用并发，并且要作到精确掌握并发的线程。可以使用NSOperationQueue。这是一个操作队列，如果将NSOperation的具体子类对象添加进来的时候，开启之后，所有的对象没有先后，会异步执行各自的代码。

- (void)operationQueue{

NSOperationQueue*queue = [[NSOperationQueuealloc] init];

NSBlockOperation*blockOp = [NSBlockOperationblockOperationWithBlock:^{

NSLog(@"%ld,%@,%@",(long)_testCount--,[NSThreadcurrentThread],[NSThreadmainThread]);

}];

NSInvocationOperation*invCationOp = [[NSInvocationOperationalloc] initWithTarget:selfselector:@selector(test2:) object:nil];

invCationOp.name = @"invocation线程";

[queue addOperation:invCationOp];

[queue addOperation:blockOp];

}

打印：

2017-05-23 15:38:45.110多线程[5772:633972] 100,{number = 3, name = (null)},{number = 1, name = (null)}

2017-05-23 15:38:45.203多线程[5772:633975] 99,{number = 4, name = (null)},{number = 1, name = (null)}

在NSOperationQueue中，正常情况下，所有的operation的执行次序是随机，如果我们想要某个operation被率先执行，可以将这个operation的优先级调高。对于优先级有以下的选择：

[invCationOp setQueuePriority:NSOperationQueuePriorityVeryHigh];

对于优先级有以下的选择：

typedefNS_ENUM(NSInteger,NSOperationQueuePriority) {

NSOperationQueuePriorityVeryLow= -8L,   最低

NSOperationQueuePriorityLow= -4L,       次低

NSOperationQueuePriorityNormal= 0,      普通  不做任何操作的operation的优先级是这个

NSOperationQueuePriorityHigh= 4,        次高

NSOperationQueuePriorityVeryHigh= 8     最高

};

当然，如果有很多operation，使用的优先级不能满足的时候，还可以设置 operation的依赖关系。 设置依赖之后，将会先执行依赖对象。

[invCationOp addDependency:blockOp];

值得注意的是：优先级和依赖关系不是冲突的。 优先级的选择会在依赖关系下发生效果，也就是，在依赖关系成立的情况下，优先级的才会有效。

三、GCD  -  Grand Central Dispatch

Grand Central Dispatch早在Mac OS X 10.6雪豹上就已经存在了。后在iOS4.0的时候被引入。Grand Central Dispatch是OS X中的一个低级框架，用于管理整个操作系统中的并发和异步执行任务。本质上，随着处理器核心的可用性，任务排队等待执行。通过允许系统控制对任务的线程分配，GCD更有效地使用资源，这有助于系统和应用程序运行更快，高效和响应。

GCD的一个重要的对象是队列：Dispatch Queue。跟Operationqueue类似，通过将Operation加入到队列中，执行相应的单元。在GCD中，大量采用了block的形式创建类似的operation。

1. Dispatch Queue  创建

Dispatch Queue 分为两类，主要是根据并行和串行来区分：

a. Serial Dispatch Queue: 线性执行的线程队列，遵循FIFO(First In First Out)原则; 又叫private dispatch queues，同时只执行一个任务。Serial queue常用于同步访问特定的资源或数据。当你创建多个Serial queue时，虽然各自是同步，但serial queue之间是并发执行。 main dipatch属于这个类别。

b. Concurrent Dispatch Queue: 并发执行的线程队列，并发执行的处理数取决于当前状态。又叫global dispatch queue，可以并发的执行多个任务，但执行完成顺序是随机的。系统提供四个全局并发队列，这四个队列有这对应的优先级，用户是不能够创建全局队列的，只能获取。

我们可以自定义队列，默认创建的队列是串行的，但是也可以指定创建一个并行的队列：

//串行队列dispatch_queue_create("com.deafultqueue", 0)

//串行队列dispatch_queue_create("com.serialqueue", DISPATCH_QUEUE_SERIAL)//并行队列dispatch_queue_create("com.concurrentqueue", DISPATCH_QUEUE_CONCURRENT)

除了自定义队列，系统其实也为有一些已经公开的队列。这些队列不需要我们显示的创建，只能通过获取的方式得到：

dispatch_get_main_queue()   获取当前的APP主队列，这个队列在主线程中，通常我们调用它进行界面的刷新。

dispatch_get_global_queue(<#long identifier#>, <#unsigned long flags#>)   获取全局的Concurrent队列，这里苹果提供了四种不同的优先级，

#define DISPATCH_QUEUE_PRIORITY_HIGH 2

#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0

#define DISPATCH_QUEUE_PRIORITY_LOW (-2)

#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN

也即时有四个不同的并行队列。

2. Dispatch Queue  执行

GCD的队列有串行和并行两种队列，同时我们可以同步和异步两种方式执行队列，所以最多有四种不同的场景。

（1）串行同步。 凡涉及到同步的的都会阻塞线程。 UI线程—也即是我们的所说的主线程默认情况下其实就是执行同步的。这个时候如果有一些耗时间的操作，则会出现卡顿的现象。这种方式大部分情况用于能快速响应和后台线程的耗时场景中。

//串行同步

dispatch_queue_t  serialQ = dispatch_queue_create("串行", DISPATCH_QUEUE_SERIAL);//创建一个串行队列

NSLog(@"%@",[NSThreadcurrentThread].description);

dispatch_sync(serialQ, ^{

[NSThreadsleepForTimeInterval:3];

NSLog(@"%@ --  %@队列",[NSThreadcurrentThread].description,[NSStringstringWithUTF8String:dispatch_queue_get_label(serialQ)]);

});

dispatch_sync(serialQ, ^{

NSLog(@"%@ --  %@队列",[NSThreadcurrentThread].description,[NSStringstringWithUTF8String:dispatch_queue_get_label(serialQ)]);

});

（2）串行异步。 这种情况下，GCD会开辟另一个新的线程，让队列中的内容在新的线程中按顺序执行。

//串行异步

dispatch_async(serialQ, ^{

NSLog(@"%@ 1-- 队列：%@",[NSThreadcurrentThread].description,[NSStringstringWithUTF8String:dispatch_queue_get_label(serialQ)]);

});

dispatch_async(serialQ, ^{

NSLog(@"%@ 2-- 队列：%@",[NSThreadcurrentThread].description,[NSStringstringWithUTF8String:dispatch_queue_get_label(serialQ)]);

});

dispatch_async(serialQ, ^{

NSLog(@"%@ 3-- 队列：%@",[NSThreadcurrentThread].description,[NSStringstringWithUTF8String:dispatch_queue_get_label(serialQ)]);

});

dispatch_async(serialQ, ^{

NSLog(@"%@ 4-- 队列：%@",[NSThreadcurrentThread].description,[NSStringstringWithUTF8String:dispatch_queue_get_label(serialQ)]);

});

（3）并行同步。 因为是同步执行，所以实际上这里的并行是没有意义的。 依然在当前的线程中按顺序执行，并阻塞。

dispatch_queue_t  conCurrentQ = dispatch_queue_create("并行", DISPATCH_QUEUE_CONCURRENT);//创建一个并行行队列

//并行同步

dispatch_sync(conCurrentQ, ^{

[NSThreadsleepForTimeInterval:0.2];

NSLog(@"%@ 1-- 队列：%@",[NSThreadcurrentThread].description,[NSStringstringWithUTF8String:dispatch_queue_get_label(conCurrentQ)] );

});

dispatch_sync(conCurrentQ, ^{

[NSThreadsleepForTimeInterval:0.2];

NSLog(@"%@ 2-- 队列：%@",[NSThreadcurrentThread].description,[NSStringstringWithUTF8String:dispatch_queue_get_label(conCurrentQ)] );

});

dispatch_sync(conCurrentQ, ^{

[NSThreadsleepForTimeInterval:0.2];

NSLog(@"%@ 3-- 队列：%@",[NSThreadcurrentThread].description,[NSStringstringWithUTF8String:dispatch_queue_get_label(conCurrentQ)] );

});

（4）并行异步。 并行异步将极大的利用资源。首先会开辟新的线程，并且，当所有线程备占用的情况下，会继续开辟（如果没有限制的话）。所以这里还涉及线程的最大值的问题。

//并行异步

dispatch_async(conCurrentQ, ^{

NSLog(@"%@ 1-- 队列：%@",[NSThreadcurrentThread].description,[NSStringstringWithUTF8String:dispatch_queue_get_label(conCurrentQ)] );

});

dispatch_async(conCurrentQ, ^{

NSLog(@"%@ 2-- 队列：%@",[NSThreadcurrentThread].description,[NSStringstringWithUTF8String:dispatch_queue_get_label(conCurrentQ)] );

});

dispatch_async(conCurrentQ, ^{

NSLog(@"%@ 3-- 队列：%@",[NSThreadcurrentThread].description,[NSStringstringWithUTF8String:dispatch_queue_get_label(conCurrentQ)] );

});

dispatch_async(conCurrentQ, ^{

NSLog(@"%@ 4-- 队列：%@",[NSThreadcurrentThread].description,[NSStringstringWithUTF8String:dispatch_queue_get_label(conCurrentQ)] );

});

3. Dispatch Queue  暂停和继续

我们可以使用dispatch_suspend函数暂停一个queue以阻止它执行block对象;使用dispatch_resume函数继续dispatch queue。调用dispatch_suspend会增加queue的引用计数,调用dispatch_resume则减少queue的引用计数。当引用计数大于0时,queue就保持挂起状态。因此你必须对应地调用suspend和resume函数。挂起和继续是异步的,而且只在执行block之间（比如在执行一个新的block之前或之后）生效。挂起一个queue不会导致正在执行的block停止。

4. Dispatch Queue  的销毁

每个队列在执行完添加到其中的所有的block事件的时候,在ARC模式下，会被自动销毁。 但是在手动管理内存的时候，我们需要调用

dispatch_release(queue);

来释放。

5.队列组  Dispatch Group （这些内容来自http://blog.csdn.net/q199109106q/article/details/8566300）

多数情况下，我们可能会遇到这种问题： 对一个页面中的多张图片，每张图片要单独的进行网络请求，我们没有办法保证每次的请求时间是一样的，但是项目经理说必须要在获取所有的图片的情况下，才可以进行对页面的刷新。这里有个很好例子可以解决这个问题。

// 根据url获取UIImage

- (UIImage *)imageWithURLString:(NSString*)urlString {

NSURL*url = [NSURLURLWithString:urlString];

NSData*data = [NSDatadataWithContentsOfURL:url];

return[UIImage imageWithData:data];

}

- (void)downloadImages {

// 异步下载图片

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

// 下载第一张图片

NSString*url1 = @"http://car0.autoimg.cn/upload/spec/9579/u_20120110174805627264.jpg";

UIImage *image1 = [selfimageWithURLString:url1];

// 下载第二张图片

NSString*url2 = @"http://hiphotos.baidu.com/lvpics/pic/item/3a86813d1fa41768bba16746.jpg";

UIImage *image2 = [selfimageWithURLString:url2];

// 回到主线程显示图片

dispatch_async(dispatch_get_main_queue(), ^{

self.imageView1.image = image1;

self.imageView2.image = image2;

});

});

}

但是我们发现，事实上，图片一和 二两者在请求的过程中是完全独立的， 但是这里明显的，图片一的下载将阻塞，直到下载完才会开始图片二的下载。这种方式毕竟还是有瑕疵的啊哈。

Dispatch Group可以帮助解决这个问题。 它是Dispatch Queue的组合，被加入到group的queue会在组内其他的queue也执行完操作的时候，有group统一调用预设好的一个block。最重要的是，在group中的内容是可以异步执行的。也即是多个队列在不同的线程执行。 如果图片大小差不多的话，这种方式将节省我们不一半的时间。  我们来看看这个模型。

//dispaach group

dispatch_queue_t queue1 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_queue_t queue2 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_group_t group = dispatch_group_create();

dispatch_group_async(group, queue1, ^{

[NSThreadsleepForTimeInterval:5.0];

NSLog(@"第一个项目执行完成。");

});

dispatch_group_async(group, queue2, ^{

[NSThreadsleepForTimeInterval:10.0]；

NSLog(@"第二个项目执行完成。");

});

dispatch_group_notify(group, dispatch_get_main_queue(), ^{

NSLog(@"集体回调");

});

6.GCD的其他的用法

（1）控制一段代码只执行一次。用在创建单例的时候再好不过了。

//控制代码只执行一次数

for(inti = 1 ;i <= 10 ;i++){

staticdispatch_once_t onceToken;

dispatch_once(&onceToken, ^{

NSLog(@"被执行 %d次",i);

});

}

打印结果：2017-05-24 18:15:17.704多线程[10542:898532]被执行1次

(2) 只能控制执行一次是不是有点不够完美 。dispatch_apply 可以让你控制一段代码执行任意多次。这里的执行是异步执行的，如果为了确保顺序执行，应该对执行的内容进行加锁。

//控制执行任意多次

dispatch_queue_t queueX = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

__blockintcount = 0;

NSLock*lock = [[NSLockalloc]init];

dispatch_apply(5, queueX, ^(size_t index) {

[lock lock];

NSLog(@"%d,%zu",count++,index);

[lock unlock];

});

（3）做一个block式的延时。 除了使用performSelector之外，我们还以使用dispatch_after进行延时，并且是以block的形式进行。

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 *NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

NSLog(@"五秒钟之后执行的代码。");

});