iOS 多线程

GCD总结
 NSOperation总结
 iOS面试题（三）多线程开发 - 简书
 iOS基础深入补完计划--多线程(面试题)汇总 - CocoaChina_让移动开发更简单
 可能碰到的iOS笔试面试题（18）--多线程 - 简书

进程

在系统中正在运行的一个应用程序，每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内
进程用于指代一个可执行程序，他可以包含多个线程（苹果官方解释）

线程

1个进程想要执行任务，必须得有线程（每一个进程至少要有1条线程），线程是进程的基本执行单元，一个进程（程序）的所有任务都在线程中执行。
线程用于指代一个独立执行的代码路径（苹果官方解释）

主线程

一个iOS程序运行后，默认会开启1条线程，称为“主线程”或者“UI线程”。
作用
- 显示/刷新UI界面
- 处理UI事件
使用注意
- 别将比较耗时的操作放在主线程中，操作影响UI的流畅度，给用户一种卡的体验

多线程

概念
- 一个程序开启多条线程，每条线程可以并行（同时）执行不同的任务
原理
- 多个线程并发执行，其实质是CPU快速地在多条线程之间调度（切换）
- 当CPU调度线程的时间足够快，就会造成多线程并发执行的假象

串行

定义
- 顺序执行,一个个执行，在同一时间内，1个线程只能执行一个任务。

并行

定义
- 可以一起执行，同一时间内，一个进程可以执行多个任务多线程：一个线程中可以开启多条线程，每条线程可以并发（同时）执行不同的任务。
优点：
- 提高程序的执行效率，能适当提高资源利用率。
缺点
- 开启线程需要占一定的内存空间，如果开启大量线程，CPU会在N多线程之间调度，CPU会累死，消耗大量的CPU资源，降低程序性能，程序设计更复杂。
  原理：同一时间内，CPU只能处理一条线程，只有1条线程在工作。多线程并发执行，其实是CPU快速的在多条线程之间切换。

多线程的方式

1.NSThread

优点：NSThread 轻量级最低，相对简单。
缺点：手动管理所有的线程活动，如生命周期、线程同步、睡眠等。

新建

//创建线程方式1
//创建
NSThread * th = [[NSThread alloc] initWithTarget:self selector:@selector(nsThreadMethod) object:nil];

//创建线程方式2
//创建并启动
[NSThread detachNewThreadSelector:@selector(nsThreadMethod) toTarget:self withObject:nil];

//隐式创建方式
 [self performSelectorInBackground:@selector(nsThreadMethod) withObject:nil];

//不传递参数指定函数在当前线程执行
[self performSelector:@selector(doSomething)];
//传递参数指定函数在当前线程执行
[self performSelector: @selector(doSomething:) withObject:tempStr];
//传递参数指定函数2秒后在当前线程执行
[self performSelector:@selector(doSomething:) withObject:tempStr afterDelay:2.0];

就绪
- 将线程放入线程池中
运行
```
 [th start];
```

阻塞

//休眠2秒
[ NSThread sleepForTimeInterval:2];
//休眠到指定时间
[NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:5.0]];

销毁
```
 //结束线程
[NSThread exit];
```

指定在特定线程执行

 //在其他线程中指定在主线程执行
[self performSelectorOnMainThread:@selector(doSomething:) withObject:tempStr waitUntilDone:YES];
//在主线程指定在后台线程执行
[self performSelectorInBackground:@selector(doSomething:) withObject:tempStr];
//在主线程中指定某个特定线程执行
[self performSelector:@selector(doSomething:)  onThread:newThread withObject:tempStr waitUntilDone:YES];

线程常用属性

 //获取主线程
 [NSThread mainThread];
 //获取当前线程
 [NSThread currentThread];
 //设置线程名字
 [newThread setName:@"thread - 1"];
 //设置线程优先级
 [newThread setThreadPriority:1.0];
 //IOS 8 之后 推荐使用下面这种方式设置线程优先级
 //NSQualityOfServiceUserInteractive：最高优先级，用于用户交互事件
 //NSQualityOfServiceUserInitiated：次高优先级，用于用户需要马上执行的事件
 //NSQualityOfServiceDefault：默认优先级，主线程和没有设置优先级的线程都默认为这个优先级
 //NSQualityOfServiceUtility：普通优先级，用于普通任务
 //NSQualityOfServiceBackground：最低优先级，用于不重要的任务
 [newThread setQualityOfService:NSQualityOfServiceUtility];
 //判断线程是否是主线程
 [newThread isMainThread];
 //线程状态
 //是否已经取消
 [newThread isCancelled];
 //是否已经结束
 [newThread isFinished];
 //是否正在执行
 [newThread isExecuting];

线程的同步

线程同步就是为了解决多线程同时访问公共共享数据，而导致数据错乱的问题，然后使用同步的方式让公共数据同一时间内只能被一个线程访问来避免数据错乱的问题

实现线程同步的几种方式

1.@synchronized(对象)关键字

-(void)taskRun
{
  while (count>0) {
      @synchronized(self) { // 需要锁定的代码
          [NSThread sleepForTimeInterval:0.1];
          count--;
          NSLog(@"threadName:%@ count:%d ",[NSThread currentThread].name, count);
      }
  }

}

2.NSLock同步锁

-(void)taskRun
{
    while (count>0) {
        @synchronized(self) { // 需要锁定的代码
            [NSThread sleepForTimeInterval:0.1];
            count--;
            NSLog(@"threadName:%@ count:%d ",[NSThread currentThread].name, count);
        }
    }

}

3.NSCondition同步锁和线程检查器

//锁主要为了当检测条件时保护数据源，执行条件引发的任务；线程检查器主要是根据条件决定是否继续运行线程，即线程是否被阻塞。先创建一个NSCondition对象
condition=[[NSCondition alloc]init];

//使用同步锁的方式和NSLock相似
-(void)taskRun
{
   while (count>0) {
       [condition lock];
       [NSThread sleepForTimeInterval:0.1];
       count--;
       NSLog(@"threadName:%@ count:%d ",[NSThread currentThread].name, count);
       [condition unlock];
   }

}
//NSCondition可以让线程进行等待，然后获取到CPU发信号告诉线程不用在等待，可以继续执行，上述的例子我们稍作修改，我们让线程三专门用于发送信号源
   NSThread *thread1=[[NSThread alloc]initWithTarget:self selector:@selector(taskRun) object:nil];
   thread1.name=@"thread-1";

   NSThread *thread2=[[NSThread alloc]initWithTarget:self selector:@selector(taskRun) object:nil];
   thread2.name=@"thread-2";

   NSThread *thread3=[[NSThread alloc]initWithTarget:self selector:@selector(taskRun1) object:nil];
   thread3.name=@"thread-3";

   [thread1 start];
   [thread2 start];
   [thread3 start];
//taskRun1函数用于发送信号源
-(void)taskRun1
{
   while (YES) {
       [condition lock];
       [NSThread sleepForTimeInterval:2];
       [condition signal];
       [condition unlock];
   }
}
//taskRun函数 用于执行对count的操作
-(void)taskRun
{

   while (count>0) {
       [condition lock];
       [condition wait];
       [NSThread sleepForTimeInterval:0.1];
       count--;
       NSLog(@"threadName:%@ count:%d ",[NSThread currentThread].name, count);
       [condition unlock];
   }

}

2.GCD

优点：最高效，避开并发陷阱。
缺点：基于C实现

队列

作用：用来存放任务。

dispatch_queue_t  queue =  dispatch_queue_create("123", DISPATCH_QUEUE_SERIAL);
//“123”：队列标示。
//DISPATCH_QUEUE_SERIAL:串行
//DISPATCH_QUEUE_CONCURRENT:并行

UI主线程队列 main queue
- dispatch_get_main_queue()
串行队列
- 顺序，一个个执行。
并行队列
- 同时执行很多任务。

全局队列

//第一个参数：线程的优先级，有高，默认，低，后台，由高到低。
//第二个参数：备用，默认0,不能改成其他
dispatch_queue_t  queue = dispatch_get_global_queue(0, 0);

全局队列和并发队列的区别：
- 全局队列没有名称，并发队列有名称。
- 全局队列是所有应用程序共享。

任务
- 执行的操作
```
  dispatch_sync(queue, ^{
      //code
  });
  //queue：队列
  //dispatch_sync：同步
  //dispatch_async：异步
```
- 同步
  - dispatch_sync，不开线程，在当前线程中执行，马上执行
- 异步
  - dispatch_async，开辟线程，在另一个线程中执行，稍后执行

使用

将任务添加队列中，GCD会自定将队列中的任务取出，放到对应线程中执行，任务的取出遵循队列的FIFO原则：先进先出，后进后出。

延时线程

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 1.0 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
        //code
});

线程调度组

dispatch_group_enter、dispatch_group_leave
dispatch_group_enter 标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数+1
dispatch_group_leave 标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数-1。

当 group 中未执行完毕任务数为0的时候，才会使dispatch_group_wait解除阻塞，以及执行追加到dispatch_group_notify中的任务。

   //    实例化一个调度组
       dispatch_group_t  group = dispatch_group_create();
   //    创建队列
       dispatch_queue_t queue2 = dispatch_get_global_queue(0, 0);
   //    任务添加到队列queue
       dispatch_group_enter(group);
       dispatch_group_async(group, queue2, ^{
           //code1
         dispatch_group_leave(group);
       });

       dispatch_group_async(group, queue2, ^{
           //code2
       });

       dispatch_group_async(group, queue2, ^{
           //code3
       });
       //获取所有调度组里面的异步任务完成的通知
       dispatch_group_notify(group, queue2, ^{
           //code4
       });

一次性线程

static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _instance = [[GetToken alloc] init];
});

定时线程

//创建并行队列
dispatch_queue_t aQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0); // 并行queue
//创建一个GCD定时器
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, aQueue);
//设置定时器的参数
//第一个参数：要给哪个设置定时器。
//第二个参数：开始时间
//第三个参数：间隔时间
//第四个参数：精准度，一般为0.
dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC, 0 * NSEC_PER_SEC);
//设置定时器调用的方法。
dispatch_source_set_event_handler(timer, ^{
   
});
启动
dispatch_resume(timer);

暂停线程

暂停当前线程（阻塞当前线程），等待指定的 group 中的任务执行完成后，才会往下继续执行。

 /**
 * 队列组 dispatch_group_wait
 */
- (void)groupWait {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"group---begin");

    dispatch_group_t group =  dispatch_group_create();

    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务1
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务2
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    // 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

    NSLog(@"group---end");
}

栅栏线程

我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。dispatch_barrier_async函数会等待前边追加到并发队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。然后在dispatch_barrier_async函数追加的任务执行完毕之后，异步队列才恢复为一般动作，接着追加任务到该异步队列并开始执行

 /**
  * 栅栏方法 dispatch_barrier_async
  */
 - (void)barrier {
     dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);

     dispatch_async(queue, ^{
         // 追加任务1
         for (int i = 0; i < 2; ++i) {
             [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
             NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
         }
     });
     dispatch_async(queue, ^{
         // 追加任务2
         for (int i = 0; i < 2; ++i) {
             [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
             NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
         }
     });

     dispatch_barrier_async(queue, ^{
         // 追加任务 barrier
         for (int i = 0; i < 2; ++i) {
             [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
             NSLog(@"barrier---%@",[NSThread currentThread]);// 打印当前线程
         }
     });

     dispatch_async(queue, ^{
         // 追加任务3
         for (int i = 0; i < 2; ++i) {
             [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
             NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
         }
     });
     dispatch_async(queue, ^{
         // 追加任务4
         for (int i = 0; i < 2; ++i) {
             [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
             NSLog(@"4---%@",[NSThread currentThread]);      // 打印当前线程
         }
     });
 }
     /*
 2018-02-23 20:48:18.297745+0800 YSC-GCD-demo[20188:5059274] 1---<NSThread: 0x600000079d80>{number = 4, name = (null)}
 2018-02-23 20:48:18.297745+0800 YSC-GCD-demo[20188:5059273] 2---<NSThread: 0x600000079e00>{number = 3, name = (null)}
 2018-02-23 20:48:20.301139+0800 YSC-GCD-demo[20188:5059274] 1---<NSThread: 0x600000079d80>{number = 4, name = (null)}
 2018-02-23 20:48:20.301139+0800 YSC-GCD-demo[20188:5059273] 2---<NSThread: 0x600000079e00>{number = 3, name = (null)}
 2018-02-23 20:48:22.306290+0800 YSC-GCD-demo[20188:5059274] barrier---<NSThread: 0x600000079d80>{number = 4, name = (null)}
 2018-02-23 20:48:24.311655+0800 YSC-GCD-demo[20188:5059274] barrier---<NSThread: 0x600000079d80>{number = 4, name = (null)}
 2018-02-23 20:48:26.316943+0800 YSC-GCD-demo[20188:5059273] 4---<NSThread: 0x600000079e00>{number = 3, name = (null)}
 2018-02-23 20:48:26.316956+0800 YSC-GCD-demo[20188:5059274] 3---<NSThread: 0x600000079d80>{number = 4, name = (null)}
 2018-02-23 20:48:28.320660+0800 YSC-GCD-demo[20188:5059273] 4---<NSThread: 0x600000079e00>{number = 3, name = (null)}
 2018-02-23 20:48:28.320649+0800 YSC-GCD-demo[20188:5059274] 3---<NSThread: 0x600000079d80>{number = 4, name = (null)}

     */

快速迭代方法

通常我们会用 for 循环遍历，但是 GCD 给我们提供了快速迭代的函数dispatch_apply。dispatch_apply按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束
如果是在串行队列中使用 dispatch_apply，那么就和 for 循环一样，按顺序同步执行。可这样就体现不出快速迭代的意义了。
我们可以利用并发队列进行异步执行。比如说遍历 0~5 这6个数字，for 循环的做法是每次取出一个元素，逐个遍历。dispatch_apply 可以在多个线程中同时（异步）遍历多个数字。

还有一点，无论是在串行队列，还是异步队列中，dispatch_apply 都会等待全部任务执行完毕，这点就像是同步操作，也像是队列组中的 dispatch_group_wait方法。

/**
* 快速迭代方法 dispatch_apply
*/
- (void)apply {
   dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

   NSLog(@"apply---begin");
   dispatch_apply(6, queue, ^(size_t index) {
       NSLog(@"%zd---%@",index, [NSThread currentThread]);
   });
   NSLog(@"apply---end");
}      
    /*
2018-02-23 22:03:18.475499+0800 YSC-GCD-demo[20470:5176805] apply---begin
2018-02-23 22:03:18.476672+0800 YSC-GCD-demo[20470:5177035] 1---<NSThread: 0x60000027b8c0>{number = 3, name = (null)}
2018-02-23 22:03:18.476693+0800 YSC-GCD-demo[20470:5176805] 0---<NSThread: 0x604000070640>{number = 1, name = main}
2018-02-23 22:03:18.476704+0800 YSC-GCD-demo[20470:5177037] 2---<NSThread: 0x604000276800>{number = 4, name = (null)}
2018-02-23 22:03:18.476735+0800 YSC-GCD-demo[20470:5177036] 3---<NSThread: 0x60000027b800>{number = 5, name = (null)}
2018-02-23 22:03:18.476867+0800 YSC-GCD-demo[20470:5177035] 4---<NSThread: 0x60000027b8c0>{number = 3, name = (null)}
2018-02-23 22:03:18.476867+0800 YSC-GCD-demo[20470:5176805] 5---<NSThread: 0x604000070640>{number = 1, name = main}
2018-02-23 22:03:18.477038+0800 YSC-GCD-demo[20470:5176805] apply---end
     */

semaphore 加锁

    /**
* 线程安全：使用 semaphore 加锁
* 初始化火车票数量、卖票窗口(线程安全)、并开始卖票
*/
- (void)initTicketStatusSave {
   NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
   NSLog(@"semaphore---begin");

   semaphoreLock = dispatch_semaphore_create(1);

   self.ticketSurplusCount = 50;

   // queue1 代表北京火车票售卖窗口
   dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL);
   // queue2 代表上海火车票售卖窗口
   dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL);

   __weak typeof(self) weakSelf = self;
   dispatch_async(queue1, ^{
       [weakSelf saleTicketSafe];
   });

   dispatch_async(queue2, ^{
       [weakSelf saleTicketSafe];
   });
}

/**
* 售卖火车票(线程安全)
*/
- (void)saleTicketSafe {
   while (1) {
       // 相当于加锁
       dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);

       if (self.ticketSurplusCount > 0) {  //如果还有票，继续售卖
           self.ticketSurplusCount--;
           NSLog(@"%@", [NSString stringWithFormat:@"剩余票数：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
           [NSThread sleepForTimeInterval:0.2];
       } else { //如果已卖完，关闭售票窗口
           NSLog(@"所有火车票均已售完");

           // 相当于解锁
           dispatch_semaphore_signal(semaphoreLock);
           break;
       }

       // 相当于解锁
       dispatch_semaphore_signal(semaphoreLock);
   }
}

总结
- 1.串行队列同步执行：不开线程，在原来线程里面一个一个顺序执行。
- 2.串行队列异步执行：开一条线程，在新来线程里面一个一个顺序执行。
- 3.并行队列异步执行：开多个线程，并发执行
- 4.并行队列同步执行：不开线程，在原来线程里面一个一个顺序执行。
- 1.开不开线程，由执行任务方法决定，同步不开线程，异步开线程。
- 2.开多少线程，由队列决定，串行最多开一个线程，并发可以开多个线程，具体开多少个，GCD底层决定，开发者不能控制。
  
  3bed772b.png

3.NSOperation

优点：自带线程周期管理，操作上可更注重自己逻辑。
缺点：面向对象的抽象类，只能实现它或者使用它定义好的两个子类：NSInvocationOperation 和 NSBlockOperation。
NSOperation、NSOperationQueue 简介
- 是苹果提供给我们的一套多线程解决方案。实际上 NSOperation、NSOperationQueue 是基于 GCD 更高一层的封装，完全面向对象。但是比 GCD 更简单易用、代码可读性也更高。
为什么要使用 NSOperation、NSOperationQueue？
- 可添加完成的代码块，在操作完成后执行。
- 添加操作之间的依赖关系，方便的控制执行顺序。
- 设定操作执行的优先级。
- 可以很方便的取消一个操作的执行。
- 使用 KVO 观察对操作执行状态的更改：isExecuteing、isFinished、isCancelled。
操作（Operation）
- 执行操作的意思，换句话说就是你在线程中执行的那段代码。
- 在 GCD 中是放在 block 中的。在 NSOperation 中，我们使用 NSOperation 子类 NSInvocationOperation、NSBlockOperation，或者自定义子类来封装操作。
操作队列（Operation Queues）
- 这里的队列指操作队列，即用来存放操作的队列。不同于 GCD 中的调度队列 FIFO（先进先出）的原则。NSOperationQueue 对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。
- 操作队列通过设置最大并发操作数（maxConcurrentOperationCount）来控制并发、串行。
- NSOperationQueue 为我们提供了两种不同类型的队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行。
使用步骤
- NSOperation 需要配合 NSOperationQueue 来实现多线程。因为默认情况下，NSOperation 单独使用时系统同步执行操作，配合 NSOperationQueue 我们能更好的实现异步执行。
- 1.创建操作：先将需要执行的操作封装到一个 NSOperation 对象中。
- 2.创建队列：创建 NSOperationQueue 对象。
- 3.将操作加入到队列中：将 NSOperation 对象添加到 NSOperationQueue 对象中。

基本使用

使用子类 NSInvocationOperation

      /**
 * 使用子类 NSInvocationOperation
 */
- (void)useInvocationOperation {

    // 1.创建 NSInvocationOperation 对象
    NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil];

    // 2.调用 start 方法开始执行操作
    [op start];
}

/**
 * 任务1
 */
- (void)task1 {
    for (int i = 0; i < 2; i++) {
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
    }
}

使用子类 NSBlockOperation

/**
 * 使用子类 NSBlockOperation
 */
- (void)useBlockOperation {

    // 1.创建 NSBlockOperation 对象
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
//追加
  [op addExecutionBlock:^{
        //code
    }];

    // 2.调用 start 方法开始执行操作
    [op start];
}

自定义继承自 NSOperation 的子类，通过实现内部相应的方法来封装操作。

队列

主队列

// 主队列获取方法
NSOperationQueue * queue = [NSOperationQueue mainQueue];

非主队列（默认是并发队列）

// 自定义队列创建方法
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
//获取当前队列
NSOperationQueue * queue = [NSOperationQueue currentQueue];

将操作加入到队列中

NSInvocationOperation

    NSInvocationOperation
 //    创建队列
     NSOperationQueue * queue = [[NSOperationQueue alloc] init];
 //    封装操作
     NSInvocationOperation  * op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(test) object:nil];
 //    把操作添加到队列中
     [queue addOperation:op];

NSBlockOperation

//    创建队列
   NSOperationQueue * queue = [[NSOperationQueue alloc] init];
//    封装操作
   NSBlockOperation * bl = [NSBlockOperation blockOperationWithBlock:^{
   //code
}];
     [bl addExecutionBlock:^{
       //code,追加操作，这一步，可加可不加。
   }]
   //    把操作添加到队列中
   [queue addOperation:bl];
简写方式
  [queue addOperationWithBlock:^{
       //code
   }];

串行和并行

这里有个关键参数maxConcurrentOperationCount，叫做最大并发数。

maxConcurrentOperationCount默认情况下为-1，表示不进行限制，默认为并发执行。
当maxConcurrentOperationCount为1时，队列为串行队列。只能串行执行。
当maxConcurrentOperationCount大于1时，队列为并发队列。操作并发执行，当然这个值不应超过系统限制，即使自己设置一个很大的值，系统也会自动调整。

/**
 * 设置 MaxConcurrentOperationCount（最大并发操作数）
 */
- (void)setMaxConcurrentOperationCount {

    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2.设置最大并发操作数
    queue.maxConcurrentOperationCount = 1; // 串行队列
// queue.maxConcurrentOperationCount = 2; // 并发队列
// queue.maxConcurrentOperationCount = 8; // 并发队列

    // 3.添加操作
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"4---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
}

线程依赖

NSOperation和NSOperationQueue最吸引人的地方是它能添加操作之间的依赖关系。比如说有A、B两个操作，其中A执行完操作，B才能执行操作，那么就需要让B依赖于A。
-(void)addDependency:(NSOperation *)op; 添加依赖，使当前操作依赖于操作 op 的完成。
-(void)removeDependency:(NSOperation *)op; 移除依赖，取消当前操作对操作 op 的依赖。
@property (readonly, copy) NSArray<NSOperation *> *dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组。

/**
* 操作依赖
* 使用方法：addDependency:
*/
- (void)addDependency {

   // 1.创建队列
   NSOperationQueue *queue = [[NSOperationQueue alloc] init];

   // 2.创建操作
   NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
       for (int i = 0; i < 2; i++) {
           [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
           NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
       }
   }];
   NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
       for (int i = 0; i < 2; i++) {
           [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
           NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
       }
   }];

   // 3.添加依赖
   [op2 addDependency:op1]; // 让op2 依赖于 op1，则先执行op1，在执行op2

   // 4.添加操作到队列中
   [queue addOperation:op1];
   [queue addOperation:op2];
}

线程优先级
- NSOperation 提供了queuePriority（优先级）属性，queuePriority属性适用于同一操作队列中的操作，不适用于不同操作队列中的操作。默认情况下，所有新创建的操作对象优先级都是NSOperationQueuePriorityNormal。但是我们可以通过setQueuePriority:方法来改变当前操作在同一队列中的执行优先级。
```
 // 优先级的取值
 typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
     NSOperationQueuePriorityVeryLow = -8L,
     NSOperationQueuePriorityLow = -4L,
     NSOperationQueuePriorityNormal = 0,
     NSOperationQueuePriorityHigh = 4,
     NSOperationQueuePriorityVeryHigh = 8
 };
```
- 什么样的操作才是进入就绪状态的操作呢？
  - 当一个操作的所有依赖都已经完成时，操作对象通常会进入准备就绪状态，等待执行。
- 举个例子，现在有4个优先级都是 NSOperationQueuePriorityNormal（默认级别）的操作：op1，op2，op3，op4。其中 op3 依赖于 op2，op2 依赖于 op1，即 op3 -> op2 -> op1。现在将这4个操作添加到队列中并发执行。
  - 因为 op1 和 op4 都没有需要依赖的操作，所以在 op1，op4 执行之前，就是处于准备就绪状态的操作。
  - 而 op3 和 op2 都有依赖的操作（op3 依赖于 op2，op2 依赖于 op1），所以 op3 和 op2 都不是准备就绪状态下的操作。
- 理解了进入就绪状态的操作，那么我们就理解了queuePriority 属性的作用对象
  - queuePriority 属性决定了进入准备就绪状态下的操作之间的开始执行顺序。并且，优先级不能取代依赖关系。
  - 如果一个队列中既包含高优先级操作，又包含低优先级操作，并且两个操作都已经准备就绪，那么队列先执行高优先级操作。比如上例中，如果 op1 和 op4 是不同优先级的操作，那么就会先执行优先级高的操作。
  - 如果，一个队列中既包含了准备就绪状态的操作，又包含了未准备就绪的操作，未准备就绪的操作优先级比准备就绪的操作优先级高。那么，虽然准备就绪的操作优先级低，也会优先执行。优先级不能取代依赖关系。如果要控制操作间的启动顺序，则必须使用依赖关系。

线程同步

/**
* 线程安全：使用 NSLock 加锁
* 初始化火车票数量、卖票窗口(线程安全)、并开始卖票
*/

- (void)initTicketStatusSave {
   NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程

   self.ticketSurplusCount = 50;

   self.lock = [[NSLock alloc] init];  // 初始化 NSLock 对象

   // 1.创建 queue1,queue1 代表北京火车票售卖窗口
   NSOperationQueue *queue1 = [[NSOperationQueue alloc] init];
   queue1.maxConcurrentOperationCount = 1;

   // 2.创建 queue2,queue2 代表上海火车票售卖窗口
   NSOperationQueue *queue2 = [[NSOperationQueue alloc] init];
   queue2.maxConcurrentOperationCount = 1;

   // 3.创建卖票操作 op1
   NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
       [self saleTicketSafe];
   }];

   // 4.创建卖票操作 op2
   NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
       [self saleTicketSafe];
   }];

   // 5.添加操作，开始卖票
   [queue1 addOperation:op1];
   [queue2 addOperation:op2];
}

/**
* 售卖火车票(线程安全)
*/
- (void)saleTicketSafe {
   while (1) {

       // 加锁
       [self.lock lock];

       if (self.ticketSurplusCount > 0) {
           //如果还有票，继续售卖
           self.ticketSurplusCount--;
           NSLog(@"%@", [NSString stringWithFormat:@"剩余票数:%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]);
           [NSThread sleepForTimeInterval:0.2];
       }

       // 解锁
       [self.lock unlock];

       if (self.ticketSurplusCount <= 0) {
           NSLog(@"所有火车票均已售完");
           break;
       }
   }
}

NSOperation 常用属性和方法
- 取消操作方法
  - -(void)cancel; 可取消操作，实质是标记 isCancelled 状态。
- 判断操作状态方法
  - -(BOOL)isFinished; 判断操作是否已经结束。
  - -(BOOL)isCancelled; 判断操作是否已经标记为取消。
  - -(BOOL)isExecuting; 判断操作是否正在在运行。
  - -(BOOL)isReady; 判断操作是否处于准备就绪状态，这个值和操作的依赖关系相关。
- 操作同步
  - -(void)waitUntilFinished; 阻塞当前线程，直到该操作结束。可用于线程执行顺序的同步。
  - -(void)setCompletionBlock:(void (^)(void))block; completionBlock 会在当前操作执行完毕时执行 completionBlock。
  - -(void)addDependency:(NSOperation *)op; 添加依赖，使当前操作依赖于操作 op 的完成。
  - -(void)removeDependency:(NSOperation *)op; 移除依赖，取消当前操作对操作 op 的依赖。
  - @property (readonly, copy) NSArray<NSOperation *> *dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组。
NSOperationQueue 常用属性和方法
- 取消/暂停/恢复操作
  - -(void)cancelAllOperations; 可以取消队列的所有操作。
  - -(BOOL)isSuspended; 判断队列是否处于暂停状态。 YES 为暂停状态，NO 为恢复状态。
  - -(void)setSuspended:(BOOL)b; 可设置操作的暂停和恢复，YES 代表暂停队列，NO 代表恢复队列。
- 操作同步
  - -(void)waitUntilAllOperationsAreFinished; 阻塞当前线程，直到队列中的操作全部执行完毕。
- 添加/获取操作`
  - -(void)addOperationWithBlock:(void (^)(void))block; 向队列中添加一个 NSBlockOperation 类型操作对象。
  - -(void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait; 向队列中添加操作数组，wait 标志是否阻塞当前线程直到所有操作结束
  - -(NSArray *)operations; 当前在队列中的操作数组（某个操作执行结束后会自动从这个数组清除）。
  - -(NSUInteger)operationCount; 当前队列中的操作数。
- 获取队列
  - +(id)currentQueue; 获取当前队列，如果当前线程不是在 NSOperationQueue 上运行则返回 nil。
  - +(id)mainQueue; 获取主队列。
注意：
- 1.这里的暂停和取消（包括操作的取消和队列的取消）并不代表可以将当前的操作立即取消，而是当当前的操作执行完毕之后不再执行新的操作。
- 2.暂停和取消的区别就在于：暂停操作之后还可以恢复操作，继续向下执行；而取消操作之后，所有的操作就清空了，无法再接着执行剩下的操作。