在日常的程序开发中，会遇到各式各样的需求，也就需要各种操作，而一些操作会非常的占用时间和资源，例如：文件的下载，图像的描绘，以及一些复杂的算法。如果都将他们放在主线程里面，主线程负责更新的UI和处理用户的点击触摸事件就有可能被延时或者搁置，阻塞线程的正常运行。因此产生的页面卡顿以及假死极大的降低了用户体验，因此就需要用到多线程技术，将耗时耗事的操作放到另外一个线程里去执行，保证主线程的运行效率。
多线程.jpg
iOS里面有多个主线程的技术：
1. NSTread (iOS 2.0)：是一种比较轻量级的线程管理方法。需要管理线程的生命周期，以及线程同步，线程加锁等操作，需要额外的性能开销，且操作比较繁琐。
2. Cocoa Operations(iOS 2.0)：是OC原生的一种线程处理技术，相关的实现类NSOperationQueue和NSOperation。他不需要关心线程的管理以及同步等问题。
3. Grand Central Dispatch(简称GCD，iOS4.0才开始支持)：是一个提供了一些新特性、运行库来适配多核的C语言库。它可以提升工程在多核CPU上运行效率，是苹果比较推崇的方法。
注：在开辟新线程的时候也是会占用系统的资源的，主线程一般占用1M的内存，而新开的线程一般是512K，因此，线程开辟也要注意系统的内存使用。
一、NSTread的用法###
1. 动态方法
- (id)initWithTarget:(id)target selector:(SEL)selector object:(id)argument;
// 初始化线程 需要传的参数通过object传输
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
// 设置线程的优先级(0.0 ~ 1.0，1.0最高级)
thread.threadPriority = 1;
// 开启线程
[thread start];
2. 静态方法
+ (void)detachNewThreadSelector:(SEL)selector toTarget:(id)target withObject:(id)argument;
[NSThread detachNewThreadSelector:@selector(run) toTarget:self withObject:nil];
// 调用完毕后，会马上创建并开启新线程
3. 隐藏方法，NSObjct都能够调用。
//是重新创建一个子线程执行的任务
[self performSelectorInBackground:@selector(run) withObject:nil];
//获取当前线程的方法
NSThread *current = [NSThread currentThread];
//获取主线程的方法
NSThread *main = [NSThread mainThread];
//暂停当前线程
//暂停2s
[NSThread sleepForTimeInterval:2];
// 或者
NSDate *date = [NSDate dateWithTimeInterval:2 sinceDate:[NSDate date]];
[NSThread sleepUntilDate:date];
4. 线程之间的通信
1. 在指定线程上执行操作
[self performSelector:@selector(run) onThread:thread withObject:nil waitUntilDone:YES];
2. 在主线程上执行操作
[self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:YES];
3. 在当前线程执行操作
[self performSelector:@selector(run) withObject:nil];
5. 线程任务的取消和线程的销毁
1. [NSThread exit];用于在子线程中销毁某个正在运行的子线程
2. [[NSThread mainThread] cancel];用于主线程中，摸个正在运行的线程调用cancel方法，使线程正在进行的任务取消，但是线程并没有销毁。
3. 用于某个线程结束某个操作
[NSThread cancelPreviousPerformRequestsWithTarget:<#(nonnull id)#> selector:<#(nonnull SEL)#> object:<#(nullable id)#>];
注：NSThread无法进行线程先后顺序的排列，每个线程都是并发的，同时的执行。
二、NSOperation的用法
NSOperation是一个抽象类，并不能够直接应用到线程管理上，通常的是使用其子类： NSInvocationOperation、 NSBlockOperation或者自定义一个子类并添加到NSOperationQueue中
1. NSInvocationOperation，创建之后调用start方法启动任务
NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run:) object:@"dog"];
[operation start];
2. NSBlockOperation，基本和NSInvocationOperation一致，只是调用方法的时候是调用的代码块。
NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^(){
NSLog(@"执行了一个新的操作");
}];
// 开始执行任务
[operation start];
注：调用start方法开启任务，并没有开启新的线程，也是在主线程里面进行的任务操作，只有加入到NSOperationQueue之后才开辟新的线程进行任务执行。
3. NSOperationQueue
// 创建Operation的队列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 获取当前队列
[NSOperationQueue currentQueue];
// 获取到主队列
[NSOperationQueue mainQueue];
// 创建operation
NSInvocationOperation *operation1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(jump:) object:@"dog"];
NSInvocationOperation *operation2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run:) object:@"dog"];
// 添加operation之间的依赖关系，实现任务排序,operation2执行完之后才执行operation1这是NSOperationQueue比NSTread强大的地方，控制任务顺序执行
[operation1 addDependency:operation2];
// 将操作添加到队列里面之后任务就开始启动
[queue addOperation:operation1];
[queue addOperation:operation2];
// 队列最多可以添加的任务数量
queue.maxConcurrentOperationCount = 3;
// 当前队列里面的任务数量
NSInteger count = queue.operationCount;
// 取消队列里面所有的操作
[queue cancelAllOperations];
添加依赖关系后的执行顺序.png
三、CGD的基本用法
- GCD里面涉及到任务的串行和并行，串行即任务一个接一个的有序执行，形成一串。并行即任务同时执行。
- GCD里面涉及到任务的同步（sync）和异步（async），同步即任务在被加到队列里面以后就马上执行。异步即任务任务再加到队列以后，在某个不确定的时间里执行。
- GCD里面分三个常用的队列
3.1 全局队列，为并行队列（DISPATCH_QUEUE_PRIORITY_DEFAULT为队列的优先级）
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
3.2 串行队列
dispatch_queue_create(DISPATCH_QUEUE_SERIAL, 0)
3.3 主队列
dispatch_get_main_queue()
- 各个队列的同步异步操作
下面的代码在各个情况下的队列里执行的情况
- (void)task1
{
for (NSInteger i = 0; i < 2; i ++) {
NSLog(@"任务一 第%ld次----- %@",i,[NSThread currentThread]);
}
}
- (void)task2
{
for (NSInteger i = 0; i < 2; i ++) {
NSLog(@"任务二 第%ld次----- %@",i,[NSThread currentThread]);
}
}
- (void)task3
{
for (NSInteger i = 0; i < 2; i ++) {
NSLog(@"任务三 第%ld次----- %@",i,[NSThread currentThread]);
}
}
- (void)task4
{
for (NSInteger i = 0; i < 2; i ++) {
NSLog(@"任务四 第%ld次----- %@",i,[NSThread currentThread]);
}
}
- (void)task5
{
for (NSInteger i = 0; i < 2; i ++) {
NSLog(@"任务五 第%ld次----- %@",i,[NSThread currentThread]);
}
}
4.1 全局队列的同步操作
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
NSLog(@"开始执行");
dispatch_sync(queue, ^{
[self task1];
});
dispatch_sync(queue, ^{
[self task2];
});
dispatch_sync(queue, ^{
[self task3];
});
dispatch_sync(queue, ^{
[self task4];
});
dispatch_sync(queue, ^{
[self task5];
});
NSLog(@"执行完毕");
全局队列同步操作.png
全局队列的异步操作
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
NSLog(@"开始执行");
dispatch_async(queue, ^{
[self task1];
});
dispatch_async(queue, ^{
[self task2];
});
dispatch_async(queue, ^{
[self task3];
});
dispatch_async(queue, ^{
[self task4];
});
dispatch_async(queue, ^{
[self task5];
});
NSLog(@"执行完毕");
全局队列异步操作.png
4.2 串行队列的同步操作
dispatch_queue_t que = dispatch_queue_create(DISPATCH_QUEUE_SERIAL, 0);
NSLog(@"开始执行");
dispatch_sync(que, ^{
[self task1];
});
dispatch_sync(que, ^{
[self task2];
});
dispatch_sync(que, ^{
[self task3];
});
dispatch_sync(que, ^{
[self task4];
});
dispatch_sync(que, ^{
[self task5];
});
NSLog(@"执行完毕");
串行队列同步操作.png
串行队列的异步操作
dispatch_queue_t que = dispatch_queue_create(DISPATCH_QUEUE_SERIAL, 0);
NSLog(@"开始执行");
dispatch_async(que, ^{
[self task1];
});
dispatch_async(que, ^{
[self task2];
});
dispatch_async(que, ^{
[self task3];
});
dispatch_async(que, ^{
[self task4];
});
dispatch_async(que, ^{
[self task5];
});
NSLog(@"执行完毕");
串行队列异步操作.png
4.3 主队列的同步操作
dispatch_queue_t queueue = dispatch_get_main_queue();
NSLog(@"开始执行");
dispatch_sync(queueue, ^{
[self task1];
});
dispatch_sync(queueue, ^{
[self task2];
});
dispatch_sync(queueue, ^{
[self task3];
});
dispatch_sync(queueue, ^{
[self task4];
});
dispatch_sync(queueue, ^{
[self task5];
});
NSLog(@"执行完毕");
主线程同步操作.png
注：由于主线程是运行程序的主干道，当线程正在执行任务的时候，突然又给他添加一个同步执行的命令，造成崩溃。
主队列的异步操作
dispatch_queue_t queueue = dispatch_get_main_queue();
NSLog(@"开始执行");
dispatch_async(queueue, ^{
[self task1];
});
dispatch_async(queueue, ^{
[self task2];
});
dispatch_async(queueue, ^{
[self task3];
});
dispatch_async(queueue, ^{
[self task4];
});
dispatch_async(queueue, ^{
[self task5];
});
NSLog(@"执行完毕");
主线程的异步操作.png
5.GCD一些常用的其他方法
5.1 用于创建只执行一次的方法，且是线程安全的
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
//默认是线程安全的，且只执行一次
});
5.2 用于创建延迟执行的方法,其中 NSEC_PER_SEC 是单位秒
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(<#delayInSeconds#> * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
});
5.3 用于创建定时器
注：1.dispatch_source_t要写成成员变量防止在没有使用的时候就提前释放
2.由于NSTimer是加在RunLoop里面的，而RunLoop相对来说比较繁忙，所以用dispatch_source_t定义的定时器相对来说是比较精确的。
__block int count = 0;
dispatch_queue_t que = dispatch_get_main_queue();
self.timers = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, que);
dispatch_time_t starts = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC));
uint64_t invalid = (uint64_t)(1.0 * NSEC_PER_SEC);
dispatch_source_set_timer(self.timers, starts, invalid, 0);
dispatch_source_set_event_handler(self.timers, ^{
NSLog(@"哈哈哈哈");
count ++;
if (count == 8) {
dispatch_cancel(self.timers);
self.timers = nil;
}
});
dispatch_resume(self.timers);
5.4用于某些任务的重复执行
注：由于dispatch_apply是同步执行的，所以要使用主线程之外的线程，防止程序闪退
dispatch_apply(5, dispatch_get_global_queue(0, 0), ^(size_t sd) {
NSLog(@"@@@@@@@@");
});
最最最后，提醒一下，多线程操作最好放在@autoreleasepool里面，否则偶尔产生的内存泄漏将是你程序中的埋藏的炸弹
另外附上多线程经典的卖票案例：SaleTickets
