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 的过程如下:

1. 使用 dispatch_semaphore_create 函数创建 semaphore，指定正数值表示 资源的可用数量
2. 在每个任务中，调用 dispatch_semaphore_wait 来等待 semaphore
3. 当上面调用返回时，获得资源并开始工作
4. 使用完资源后，调用 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

-(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{

}