多线程
1.何为多线程
- 多线程是一个应用程序同时执行多个任务，线程是执行程序的最基本单元，他有自己的栈和寄 存器，线程既是一个CPU执行的无分叉的命令列。多个任务即意味着有多组栈和寄存器中的值需要不断地被备份、替换。因此多线程本身会带来效率上的损失，不考虑其他任何因素和技术多线程是会降低效率的。
- 准确来说，在处理并发任务时，多线程不仅不能提高效率，反而还会降低程序效率
2. 并发和并行
- 并发指的是一种现象，一种经常出现，无可避免的现象，它描述的是“多个任务同时发生，需要被处理” 这一现象，它的侧重点在与发生。
比如很多人排队等待检票，这一现象就可以理解为并发
- 并行指的是一种技术，一个同时处理多个任务的技术，他描述了一种同时能够处理多个任务的能力，侧重点在于“运行”
比如景点开放了多个检票窗口，同一时间内服务多个游客，这种情况可以理解为并行。
*我们经常挂在嘴边的“多线程”，正是采用了并行技术，从而提高了执行效率。因为有多个线程，所以计算机的多个CPU可以同时工作，同时处理不同线程内的指令。
并发是一种现象，面对这一现象，我们首先创建多个线程，真正加快程序运行速度的，是并行技术。也就是让多个CPU同时工作。而多线程，是为了让多个CPU同时工作成为可能
3.总结
于是我们可以得出结论，在需要同时处理IO和UI的情况下，真正起作用的是异步，而不是多线程，可以不用多线程，但是不能不用异步
2.常用的多线程方案 NSThread、GCD、NSOperation & NSOperationQueue
1.NSThread
NSThread是Objective-C的基础框架的一部分，并为开发者提供一种方法来创建和管理线程
特点：
- 基于OC的语言API，面向对象操作，可以直接操控线程对象，非常直观和方便。
- 线程的生命周期由程序员管理，偶尔使用（多用于debug）
示例 NSThread：
- (void)creatThread{
NSThread *thread =[[NSThread alloc]initWithTarget:self selector:@selector(runThead) object:nil];
[thread start];
/* 创建并且自动启动 */
[NSThread detachNewThreadSelector:@selector(runThead2) toTarget:self withObject:nil];
/* 使用 NSObject 的方法创建并自动启动 */
[self performSelectorInBackground:@selector(runThead3) withObject:nil];
}
- (void)runThead{
NSLog(@"创建线程1:%@", [NSThread currentThread]);
}
- (void)runThead2{
NSLog(@"自动启动线程2%@", [NSThread currentThread]);
}
- (void)runThead3{
NSLog(@"自动启动线程3%@", [NSThread currentThread]);
}
2.GCD
GCD为Grand Central Dispatch的缩写 它是苹果为多核的并行运算提出的解决方案，所以会自动合理地利用更多的CPU内核（比如双核、四核），最重要的是它会自动管理线程的生命周期（创建线程、调度任务、销毁线程），完全不需要我们管理，我们只需要告诉干什么就行。同时它使用的也是 c语言，不过由于使用了 Block（Swift里叫做闭包），使得使用起来更加方便，而且灵活
1. 任务和队列
在 GCD 中，加入了两个非常重要的概念： 任务 和 队列。
任务：即操作，你想要干什么，说白了就是一段代码，在 GCD 中就是一个 Block，所以添加任务十分方便。任务有两种执行方式： 同步执行 和 异步执行，他们之间的区别是 是否会创建新的线程。
同步和异步
<strong>同步（sync）</strong> 和 <strong>异步（async）</strong>的主要区别在于会不会阻塞当前线程，知道block中的任务执行完毕！
<strong>同步（sync）</strong>操作，他会阻塞当前线程并等待block中的任务执行完毕，然后当前线程才会继续往下运行。
<strong>异步（async）</strong>当前线程会直接往下执行，它不会阻塞当前线程
| 同步 | 异步 | |
|---|---|---|
| 主队列 | 在主线程执行 | 在主线程执行 |
| 串行队列 | 在当前线程执行 | 新建线程执行 |
| 并发队列 | 在当前线程执行 | 新建线程执行 |
dispatch_queue_t aQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
清理函数
在创建 dispatch queue 之后，可以附加一个 finalizer 函数，在 queue 被销毁之前执行自定义的清理操作。使用dispatch_set_finalizer_f 函数为 queue 指定一个清理函数，当 queue 的引用计数到达 0 时（ARC 下虽然你看不到了但是原理依然如此），且只有上下文指针不为 NULL 时才会调用这个清理函数。
添加单个任务到Queue
你可以异步或同步地添加一个任务到 Queue（异步与同步的区别就是是否阻塞当前线程）。
尽可能地使用 <strong>dispatch_async 或 dispatch_async_f </strong>函数<font color =red>异步</font>地 dispatch 任务。因为添加任务到 Queue 中时，无法确定这些代码什么时候能够执行。因此异步地添加 block 或函数，可以让你立即调度这些代码的执行，然后调用线程可以继续去做其它事情
2. GCD的死锁问题
在使用GCD的过程中，如果向当前串行队列中同步派发一个任务，就会导致死锁
绝对不要在任务中调用 dispatch_sync 或 dispatch_sync_f 函数，并同步 dispatch 新任务到当前正在执行的 queue。对于串行 queue 这一点特别重要，因为这样做肯定会导致死锁；而并发 queue 也应该避免这样做，否则虽然并发 queue 不去引起运行时错误，但是被锁的部分永远不会被执行到
- 我们知道dispatch_sync表示同步的执行任务，也就是说执行dispatch_sync后，当前队列会阻塞。而dispatch_sync中的block如果要在当前队列中执行，就得等待当前队列程执行完成
- 在上面这个例子中，主队列在执行dispatch_sync，随后队列中新增一个任务block。因为主队列是同步队列，所以block要等dispatch_sync执行完才能执行，但是dispatch_sync是同步派发，要等block执行完才算是结束。在主队列中的两个任务互相等待，导致了死锁
解决方案
- 其实在通常情况下我们不必要用dispatch_sync，因为dispatch_async能够更好的利用CPU，提升程序运行速度。
-
只有当我们需要保证队列中的任务必须顺序执行时，才考虑使用dispatch_sync。在使用dispatch_sync的时候应该分析当前处于哪个队列，以及任务会提交到哪个队列。
-
串行队列
dispatch_queue_t queue = dispatch_queue_create("", NULL);
dispatch_queue_t queue = dispatch_queue_create("test.Lision.testQueue", DISPATCH_QUEUE_SERIAL);
- 并行队列
dispatch_queue_t queue = dispatch_queue_create("test.Lision.testQueue", DISPATCH_QUEUE_CONCURRENT);
- (void)lockGCD{
dispatch_queue_t myCustomQueue =dispatch_queue_create("test.myCustomQueue", NULL);
/* 异步执行 */
dispatch_async(myCustomQueue, ^{
NSLog(@"Do some work here.\n");
});
NSLog(@"The first block may or may not have run.\n");
/* 同步执行 */
dispatch_sync(myCustomQueue, ^{
NSLog(@"同步非主队列");
});
// 由于上面的操作是同步操作会阻塞当前线程，所以执行下面的打印时上面的操作肯定是已经完毕的
NSLog(@"同步非主队列Both blocks have completed.\n");
/* 如国是当前线程同步执行则会引发死锁 */
dispatch_queue_t myMainQueue =dispatch_get_main_queue();
dispatch_sync(myMainQueue, ^{
NSLog(@"同步主队列");
});
NSLog(@"同步主队列Both blocks have completed.\n");
}
3. Dispatch Queue 和线程安全性
使用 Dispatch Queue 实现应用并发时，也需要注意线程安全性
- Dispatch queue 本身是线程安全的。换句话说，你可以在应用的任意线程中提交任务到 dispatch queue，不需要使用锁或其它同步机制
- 不要在执行任务代码中调用 dispatch_sync 函数调度相同的 queue，这样做会死锁这个 queue。如果你需要 dispatch 到当前 queue，需要使用 dispatch_async 函数异步调度
- 避免在提交到 dispatch queue 的任务中获得锁，虽然在任务中使用锁是安全的，但在请求锁时，如果锁不可用，可能会完全阻塞串行 queue。类似的，并发 queue 等待锁也可能阻止其它任务的执行。如果代码需要同步，就使用串行 dispatch queue
- 虽然可以获得运行任务的底层线程的信息，最好不要这样做
4.Dispatch Semaphore(信号量)
类似于传统的 semaphore(信号量)，但是更加高效。只有当调用线程由于信号量不可用，需要阻塞时，Dispatch semaphore 才会去调用内核。如果信号量可用，就不会与内核进行交互
使用信号量可以实现对有限资源的访问控制
使用 Dispatch Semaphore 的过程如下:
- 使用 dispatch_semaphore_create 函数创建 semaphore，指定正数值表示 资源的可用数量
- 在每个任务中，调用 dispatch_semaphore_wait 来等待 semaphore
- 当上面调用返回时，获得资源并开始工作
- 使用完资源后，调用 dispatch_semaphore_signal 函数释放和 signal 这个 semaphore
#pragma mark GCD dispatch_semaphore_t信号量
- (void)semaphoreTest{
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t mySemaphoreQueue =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 创建信号 3标识资源可用数量
// 某个线程执行到这里，如果信号量值为1，那么wait方法返回1，开始执行接下来的操作。
与此同时，因为信号量变为0，其它执行到这里的线程都必须等待 */
dispatch_semaphore_t mySemaphore =dispatch_semaphore_create(3);
// 等待一个可用的文件描述符
<!-- 执行了wait方法后，信号量的值变成了0。可以进行接下来的操作。
这时候其它线程都得等待wait方法返回。
可以对array修改的线程在任意时刻都只有一个，可以安全的修改array-->
for (int i =0; i<30; i++) {
dispatch_semaphore_wait(mySemaphore, DISPATCH_TIME_FOREVER);
dispatch_async(mySemaphoreQueue, ^{
[NSThread sleepForTimeInterval:5];//模拟代码执行时间
NSLog(@"等待----执行工作 %d",i);
/*
排他操作执行结束，记得要调用signal方法，把信号量的值加1。
这样，如果有别的线程在等待wait函数返回，就由最先等待的线程执行。 */
dispatch_semaphore_signal(mySemaphore);
});
}
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
}
5.dispatch_group_notify
dispatch_group 执行完一组异步操作后可以通过 dispatch_group_notify来通知主线程，反馈信息给用户
- (void)group_notify_Test{
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group =dispatch_group_create();
// 把 queue 加入到 group
dispatch_group_async(group, queue, ^{
dispatch_async(queue, ^{
[NSThread sleepForTimeInterval:5];//模拟代码执行时间
[NSThread sleepForTimeInterval:15];//模拟代码执行时间
[NSThread sleepForTimeInterval:2];//模拟代码执行时间
NSLog(@"模拟代码完成");
});
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^(){
// 从主线程上执行 UI 界面更新
NSLog(@"从主线程上执行 UI 界面更新");
});
}
<font color =red>iOS AFNetworking 多个网络请求顺序返回数据</font>
采用信号量机制顺序打印
dispatch_group_t group=dispatch_group_create();
dispatch_semaphore_t semaphore=dispatch_semaphore_create(1);
dispatch_queue_t queue=dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
for (int i=0; i<100; i++) {
//信号量减1,如果同时开启1个以上的线程，则信号量小于等于0，此时就会阻塞该线程。
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
dispatch_group_async(group, queue, ^{
NSLog(@"test %d",i);
//每个线程执行减1后通过信号量通知加1，这样始终保持线程在10个之内
dispatch_semaphore_signal(semaphore);
});
}
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
3. NSOperation
| 类 | 描述 |
|---|---|
| NSInvocationOperation | 可以直接使用的类，基于应用的一个对象和 selector 来创建 operation object。如果你已经有现有的方法来执行需要的任务，就可以使用这个类 |
| NSBlockOperation | 可以直接使用的类，用来并发地执行一个或多个 block 对象。operation object 使用“组”的语义来执行多个 block 对象，所有相关的 block 都执行完成之后，operation object 才算完成。 |
| NSOperation | 基类，用来自定义子类 operation object。继承 NSOperation 可以完全控制 operation object 的实现，包括修改操作执行和状态报告的方式 |
-(void)InvocationOperation_Test{
NSInvocationOperation *invocation =[[NSInvocationOperation alloc]initWithTarget:self selector:@selector(operationTest) object:nil];
[invocation start];
}
- (void)blockOperation_Test{
NSBlockOperation *blockOperation =[NSBlockOperation blockOperationWithBlock:^{
NSLog(@"do code");
}];
}
- (void)operationTest{
}
