iOS学习——（转）多线程

转载自：iOS多线程全套：线程生命周期，多线程的四种解决方案，线程安全问题，GCD的使用，NSOperation的使用

一、多线程的基本概念

• 进程：可以理解成一个运行中的应用程序，是系统进行资源分配和调度的基本单位，是操作系统结构的基础，主要管理资源。

• 线程：是进程的基本执行单元，一个进程对应多个线程。

• 主线程：处理UI，所有更新UI的操作都必须在主线程上执行。不要把耗时操作放在主线程，会卡界面。

• 多线程：在同一时刻，一个CPU只能处理1条线程，但CPU可以在多条线程之间快速的切换，只要切换的足够快，就造成了多线程一同执行的假象。

• 线程就像火车的一节车厢，进程则是火车。车厢（线程）离开火车（进程）是无法跑动的，而火车（进程）至少有一节车厢（主线程）。多线程可以看做多个车厢，它的出现是为了提高效率。

• 多线程是通过提高资源使用率来提高系统总体的效率。

• 我们运用多线程的目的是：将耗时的操作放在后台执行！

二、线程的状态与生命周期

　　下图是线程状态示意图，从图中可以看出线程的生命周期是：新建 - 就绪 - 运行 - 阻塞 - 死亡。

　　下面分别阐述线程生命周期中的每一步

• 新建：实例化线程对象

• 就绪：向线程对象发送start消息，线程对象被加入可调度线程池等待CPU调度。

• 运行：CPU 负责调度可调度线程池中线程的执行。线程执行完成之前，状态可能会在就绪和运行之间来回切换。就绪和运行之间的状态变化由CPU负责，程序员不能干预。

• 阻塞：当满足某个预定条件时，可以使用休眠或锁，阻塞线程执行。sleepForTimeInterval（休眠指定时长），sleepUntilDate（休眠到指定日期），@synchronized(self)：（互斥锁）。

• 死亡：正常死亡，线程执行完毕。非正常死亡，当满足某个条件后，在线程内部中止执行/在主线程中止线程对象

• 还有线程的exit和cancel

  • [NSThread exit]：一旦强行终止线程，后续的所有代码都不会被执行。

  • [thread cancel]取消：并不会直接取消线程，只是给线程对象添加 isCancelled 标记。

三、多线程的四种解决方案

　　多线程的四种解决方案分别是：pthread，NSThread，GCD， NSOperation。下图是对这四种方案进行了解读和对比。

四、pThread的基本使用

//使用pthread创建线程
pthread_t thread;
NSString *name = @"wendingding";
//使用pthread创建线程
//第一个参数：线程对象地址
//第二个参数：线程属性
//第三个参数：指向函数的执行
//第四个参数：传递给该函数的参数
pthread_create(&thread, NULL, run, (__bridge void *)(name));

五、NSThread的使用

No.1：NSThread创建线程

　　NSThread有三种创建方式：

• init方式

• detachNewThreadSelector创建好之后自动启动

• performSelectorInBackground创建好之后也是直接启动

/** 方法一，需要start */
NSThread *thread1 = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething1:) object:@"NSThread1"];
// 线程加入线程池等待CPU调度，时间很快，几乎是立刻执行
[thread1 start];

/** 方法二，创建好之后自动启动 */
[NSThread detachNewThreadSelector:@selector(doSomething2:) toTarget:self withObject:@"NSThread2"];

/** 方法三，隐式创建，直接启动 */
[self performSelectorInBackground:@selector(doSomething3:) withObject:@"NSThread3"];

- (void)doSomething1:(NSObject *)object {
    // 传递过来的参数
    NSLog(@"%@",object);
    NSLog(@"doSomething1：%@",[NSThread currentThread]);
}

- (void)doSomething2:(NSObject *)object {
    NSLog(@"%@",object);
    NSLog(@"doSomething2：%@",[NSThread currentThread]);
}

- (void)doSomething3:(NSObject *)object {
    NSLog(@"%@",object);
    NSLog(@"doSomething3：%@",[NSThread currentThread]);
}

No.2：NSThread的类方法

• 返回当前线程

• 阻塞休眠

• 类方法补充

// 当前线程
[NSThread currentThread];
NSLog(@"%@",[NSThread currentThread]);

// 如果number=1，则表示在主线程，否则是子线程
打印结果：{number = , name = main}

//休眠多久
[NSThread sleepForTimeInterval:];
//休眠到指定时间
[NSThread sleepUntilDate:[NSDate date]];

//退出线程
[NSThread exit];
//判断当前线程是否为主线程
[NSThread isMainThread];
//判断当前线程是否是多线程
[NSThread isMultiThreaded];
//主线程的对象

No.3：NSThread的一些属性

//线程是否在执行
thread.isExecuting;
//线程是否被取消
thread.isCancelled;
//线程是否完成
thread.isFinished;
//是否是主线程
thread.isMainThread;
//线程的优先级，取值范围0.0到1.0，默认优先级0.5，1.0表示最高优先级，优先级高，CPU调度的频率高
 thread.threadPriority;

六、GCD的理解与使用

No.1：GCD的特点

• GCD会自动利用更多的CPU内核

• GCD自动管理线程的生命周期（创建线程，调度任务，销毁线程等）

• 程序员只需要告诉 GCD 想要如何执行什么任务，不需要编写任何线程管理代码

No.2：GCD的基本概念

• 任务（block）：任务就是将要在线程中执行的代码，将这段代码用block封装好，然后将这个任务添加到指定的执行方式（同步执行和异步执行），等待CPU从队列中取出任务放到对应的线程中执行。

• 同步（sync）：一个接着一个，前一个没有执行完，后面不能执行，不开线程。

• 异步（async）：开启多个新线程，任务同一时间可以一起执行。异步是多线程的代名词

• 队列：装载线程任务的队形结构。(系统以先进先出的方式调度队列中的任务执行)。在GCD中有两种队列：串行队列和并发队列。

• 并发队列：线程可以同时一起进行执行。实际上是CPU在多条线程之间快速的切换。（并发功能只有在异步（dispatch_async）函数下才有效）

• 串行队列：线程只能依次有序的执行。

• GCD总结：将任务(要在线程中执行的操作block)添加到队列(自己创建或使用全局并发队列)，并且指定执行任务的方式(异步dispatch_async，同步dispatch_sync)

No.3：队列的创建方法

• 使用dispatch_queue_create来创建队列对象，传入两个参数，第一个参数表示队列的唯一标识符，可为空。第二个参数用来表示串行队列（DISPATCH_QUEUE_SERIAL）或并发队列（DISPATCH_QUEUE_CONCURRENT）。

  // 串行队列
  dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
  // 并发队列
  dispatch_queue_t queue1 = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);

• GCD的队列还有另外两种：

1. 主队列：主队列负责在主线程上调度任务，如果在主线程上已经有任务正在执行，主队列会等到主线程空闲后再调度任务。通常是返回主线程更新UI的时候使用。dispatch_get_main_queue()

   dispatch_async(dispatch_get_global_queue(, ), ^{
         // 耗时操作放在这里
   
         dispatch_async(dispatch_get_main_queue(), ^{
             // 回到主线程进行UI操作
   
         });
     });

2. 全局并发队列：全局并发队列是就是一个并发队列，是为了让我们更方便的使用多线程。dispatch_get_global_queue(0, 0)

   //全局并发队列
   dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, );
   //全局并发队列的优先级
   #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 // 后台优先级
   //iOS8开始使用服务质量，现在获取全局并发队列时，可以直接传0
   dispatch_get_global_queue(, );

No.4：同步/异步/任务、创建方式

• 同步（sync）使用dispatch_sync来表示。
• 异步（async）使用dispatch_async。
• 任务就是将要在线程中执行的代码，将这段代码用block封装好。

代码如下：

// 同步执行任务
    dispatch_sync(dispatch_get_global_queue(, ), ^{
        // 任务放在这个block里
        NSLog(@"我是同步执行的任务");

    });
    // 异步执行任务
    dispatch_async(dispatch_get_global_queue(, ), ^{
        // 任务放在这个block里
        NSLog(@"我是异步执行的任务");

    });

No.5：GCD的使用

　　由于有多种队列（串行/并发/主队列）和两种执行方式（同步/异步），所以他们之间可以有多种组合方式。

1. 串行同步

2. 串行异步

3. 并发同步

4. 并发异步

5. 主队列同步

6. 主队列异步

• 串行同步：执行完一个任务，再执行下一个任务。不开启新线程。

  /** 串行同步 */
  - (void)syncSerial {
  
      NSLog(@"\n\n**************串行同步***************\n\n");
      // 串行队列
      dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
      // 同步执行
      dispatch_sync(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"串行同步1   %@",[NSThread currentThread]);
          }
      });
      dispatch_sync(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"串行同步2   %@",[NSThread currentThread]);
          }
      });
      dispatch_sync(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"串行同步3   %@",[NSThread currentThread]);
          }
      });
  } 
  
  //输出结果为顺序执行，都在主线程：
  串行同步1   {number = , name = main}
  串行同步1   {number = , name = main}
  串行同步1   {number = , name = main}
  串行同步2   {number = , name = main}
  串行同步2   {number = , name = main}
  串行同步2   {number = , name = main}
  串行同步3   {number = , name = main}
  串行同步3   {number = , name = main}
  串行同步3   {number = , name = main}

• 串行异步：开启新线程，但因为任务是串行的，所以还是按顺序执行任务。

  /** 串行异步 */
  - (void)asyncSerial {
  
      NSLog(@"\n\n**************串行异步***************\n\n");
  
      // 串行队列
      dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
  
      // 异步执行
      dispatch_async(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"串行异步1   %@",[NSThread currentThread]);
          }
      });
      dispatch_async(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"串行异步2   %@",[NSThread currentThread]);
          }
      });
      dispatch_async(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"串行异步3   %@",[NSThread currentThread]);
          }
      });
  }
  
  //输出结果为顺序执行，有不同线程：
  串行异步1   {number = , name = (null)}
  串行异步1   {number = , name = (null)}
  串行异步1   {number = , name = (null)}
  串行异步2   {number = , name = (null)}
  串行异步2   {number = , name = (null)}
  串行异步2   {number = , name = (null)}
  串行异步3   {number = , name = (null)}
  串行异步3   {number = , name = (null)}
  串行异步3   {number = , name = (null)}

• 并发同步：因为是同步的，所以执行完一个任务，再执行下一个任务。不会开启新线程。

  /** 并发同步 */
  - (void)syncConcurrent {
      NSLog(@"\n\n**************并发同步***************\n\n");
      // 并发队列
      dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
      // 同步执行
      dispatch_sync(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"并发同步1   %@",[NSThread currentThread]);
          }
      });
      dispatch_sync(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"并发同步2   %@",[NSThread currentThread]);
          }
      });
      dispatch_sync(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"并发同步3   %@",[NSThread currentThread]);
          }
      });
  }
  
  //输出结果为顺序执行，都在主线程
  并发同步1   {number = , name = main}
  并发同步1   {number = , name = main}
  并发同步1   {number = , name = main}
  并发同步2   {number = , name = main}
  并发同步2   {number = , name = main}
  并发同步2   {number = , name = main}
  并发同步3   {number = , name = main}
  并发同步3   {number = , name = main}
  并发同步3   {number = , name = main}

• 并发异步：任务交替执行，开启多线程。

  /** 并发异步 */
  - (void)asyncConcurrent {
  
      NSLog(@"\n\n**************并发异步***************\n\n");
      // 并发队列
      dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
      // 异步执行
      dispatch_async(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"并发异步1   %@",[NSThread currentThread]);
          }
      });
      dispatch_async(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"并发异步2   %@",[NSThread currentThread]);
          }
      });
      dispatch_async(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"并发异步3   %@",[NSThread currentThread]);
          }
      });
  }
  
  //输出结果为无序执行，有多条线程
  并发异步1   {number = , name = (null)}
  并发异步2   {number = , name = (null)}
  并发异步3   {number = , name = (null)}
  并发异步1   {number = , name = (null)}
  并发异步2   {number = , name = (null)}
  并发异步3   {number = , name = (null)}
  并发异步1   {number = , name = (null)}
  并发异步2   {number = , name = (null)}
  并发异步3   {number = , name = (null)}

• 主队列同步：如果在主线程中运用这种方式，则会发生死锁，程序崩溃。

  主队列同步造成死锁的原因：

  1. 如果在主线程中运用主队列同步，也就是把任务放到了主线程的队列中。

  2. 而同步对于任务是立刻执行的，那么当把第一个任务放进主队列时，它就会立马执行。

  3. 可是主线程现在正在处理syncMain方法，任务需要等syncMain执行完才能执行。

  4. syncMain执行到第一个任务的时候，又要等第一个任务执行完才能往下执行第二个和第三个任务。

  5. 这样syncMain方法和第一个任务就开始了互相等待，形成了死锁。

  /** 主队列同步 */
  - (void)syncMain {
  
      NSLog(@"\n\n**************主队列同步，放到主线程会死锁***************\n\n");
      // 主队列
      dispatch_queue_t queue = dispatch_get_main_queue();
      //同步执行
      dispatch_sync(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"主队列同步1   %@",[NSThread currentThread]);
          }
      });
      dispatch_sync(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"主队列同步2   %@",[NSThread currentThread]);
          }
      });
      dispatch_sync(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"主队列同步3   %@",[NSThread currentThread]);
          }
      });
  }

• 主队列异步：在主线程中任务按顺序执行。

  /** 主队列异步 */
  - (void)asyncMain {
  
      NSLog(@"\n\n**************主队列异步***************\n\n");
      // 主队列
      dispatch_queue_t queue = dispatch_get_main_queue();
  
      dispatch_async(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"主队列异步1   %@",[NSThread currentThread]);
          }
      });
      dispatch_async(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"主队列异步2   %@",[NSThread currentThread]);
          }
      });
      dispatch_async(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"主队列异步3   %@",[NSThread currentThread]);
          }
      });
  }
  
  //输出结果为在主线程中按顺序执行
  主队列异步1   {number = , name = main}
  主队列异步1   {number = , name = main}
  主队列异步1   {number = , name = main}
  主队列异步2   {number = , name = main}
  主队列异步2   {number = , name = main}
  主队列异步2   {number = , name = main}
  主队列异步3   {number = , name = main}
  主队列异步3   {number = , name = main}
  主队列异步3   {number = , name = main}

• GCD线程之间的通讯：开发中需要在主线程上进行UI的相关操作，通常会把一些耗时的操作放在其他线程，比如说图片文件下载等耗时操作。当完成了耗时操作之后，需要回到主线程进行UI的处理，这里就用到了线程之间的通讯。下面的代码是在新开的线程中进行图片的下载，下载完成之后回到主线程显示图片。

  - (IBAction)communicationBetweenThread:(id)sender {
      // 异步
      dispatch_async(dispatch_get_global_queue(, ), ^{
          // 耗时操作放在这里，例如下载图片。（运用线程休眠两秒来模拟耗时操作）
          [NSThread sleepForTimeInterval:];
          NSString *picURLStr = @"http://www.bangmangxuan.net/uploads/allimg/160320/74-160320130500.jpg";
          NSURL *picURL = [NSURL URLWithString:picURLStr];
          NSData *picData = [NSData dataWithContentsOfURL:picURL];
          UIImage *image = [UIImage imageWithData:picData];
          // 回到主线程处理UI
          dispatch_async(dispatch_get_main_queue(), ^{
              // 在主线程上添加图片
              self.imageView.image = image;
          });
      });
  }

• GCD栅栏：当任务需要异步进行，但是这些任务需要分成两组来执行，第一组完成之后才能进行第二组的操作。这时候就用了到GCD的栅栏方法dispatch_barrier_async。

  - (IBAction)barrierGCD:(id)sender {
  
      // 并发队列
      dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
      // 异步执行
      dispatch_async(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"栅栏：并发异步1   %@",[NSThread currentThread]);
          }
      });
      dispatch_async(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"栅栏：并发异步2   %@",[NSThread currentThread]);
          }
      });
  
      dispatch_barrier_async(queue, ^{
          NSLog(@"------------barrier------------%@", [NSThread currentThread]);
          NSLog(@"******* 并发异步执行，但是34一定在12后面 *********");
      });
  
      dispatch_async(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"栅栏：并发异步3   %@",[NSThread currentThread]);
          }
      });
      dispatch_async(queue, ^{
          for (int i = ; i < ; i++) {
              NSLog(@"栅栏：并发异步4   %@",[NSThread currentThread]);
          }
      });
  }
  
  //上面代码的打印结果如下，开启了多条线程，所有任务都是并发异步进行。但是第一组完成之后，才会进行第二组的操作。
  栅栏：并发异步1   {number = , name = (null)}
  栅栏：并发异步2   {number = , name = (null)}
  栅栏：并发异步1   {number = , name = (null)}
  栅栏：并发异步2   {number = , name = (null)}
  栅栏：并发异步1   {number = , name = (null)}
  栅栏：并发异步2   {number = , name = (null)}
   ------------barrier------------{number = , name = (null)}
  ******* 并发异步执行，但是34一定在12后面 *********
  栅栏：并发异步4   {number = , name = (null)}
  栅栏：并发异步3   {number = , name = (null)}
  栅栏：并发异步4   {number = , name = (null)}
  栅栏：并发异步3   {number = , name = (null)}
  栅栏：并发异步4   {number = , name = (null)}
  栅栏：并发异步3   {number = , name = (null)}

• GCD延时执行：当需要等待一会再执行一段代码时，就可以用到这个方法了：dispatch_after。

  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
      // 5秒后异步执行
      NSLog(@"我已经等待了5秒！");
  });
  GCD实现代码只执行一次
  使用dispatch_once能保证某段代码在程序运行过程中只被执行1次。可以用来设计单例。
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
      NSLog(@"程序运行过程中我只执行了一次！");
  }); 

• GCD快速迭代：GCD有一个快速迭代的方法dispatch_apply，dispatch_apply函数是dispatch_sync函数和Dispatch Group的关联API,该函数按指定的次数将指定的Block追加到指定的Dispatch Queue中,并等到全部的处理执行结束。

  /*!
   *  @brief  dispatch_apply的用法
   */
  - (void)dispatchApplyTest1 {
      //生成全局队列
      dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, );
  
      /*! dispatch_apply函数说明
       *
       *  @brief  dispatch_apply函数是dispatch_sync函数和Dispatch Group的关联API
       *         该函数按指定的次数将指定的Block追加到指定的Dispatch Queue中,并等到全部的处理执行结束
       *
       *  @param 10    指定重复次数  指定10次
       *  @param queue 追加对象的Dispatch Queue
       *  @param index 带有参数的Block, index的作用是为了按执行的顺序区分各个Block
       *
       */
      dispatch_apply(, queue, ^(size_t index) {
          NSLog(@"%zu", index);
      });
      NSLog(@"done");
  
      /*!
       *  @brief  输出结果
       *
       2016-02-25 19:24:39.102 dispatch_apply测试[2985:165004] 0
       2016-02-25 19:24:39.102 dispatch_apply测试[2985:165086] 1
       2016-02-25 19:24:39.104 dispatch_apply测试[2985:165004] 4
       2016-02-25 19:24:39.104 dispatch_apply测试[2985:165004] 5
       2016-02-25 19:24:39.104 dispatch_apply测试[2985:165004] 6
       2016-02-25 19:24:39.103 dispatch_apply测试[2985:165088] 3
       2016-02-25 19:24:39.104 dispatch_apply测试[2985:165004] 7
       2016-02-25 19:24:39.105 dispatch_apply测试[2985:165004] 8
       2016-02-25 19:24:39.105 dispatch_apply测试[2985:165004] 9
       2016-02-25 19:24:39.102 dispatch_apply测试[2985:165087] 2
       2016-02-25 19:24:39.105 dispatch_apply测试[2985:165004] done
       *  !!!因为在Global Dispatch Queue中执行,所以各个处理的执行时间不定
       但done一定会输出在最后的位置,因为dispatch_apply函数会等待所以的处理结束
       */
  }

• GCD 控制线程数量：GCD 不像 NSOperation 那样有直接提供线程数量控制方法，但是通过 GCD 的 semaphore 功能一样可以达到控制线程数量的效果。

  1. dispatch_semaphore_create(long value); 利用给定的输出时创建一个新的可计数的信号量

  2. dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout); 如果信号量大于 0 ，信号量减 1 ，执行程序。否则等待信号量

  3. dispatch_semaphore_signal(dispatch_semaphore_t dsema); 增加信号量

     // 控制线程数量
     - (void)runMaxThreadCountWithGCD
     {
         dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrentRunMaxThreadCountWithGCD", DISPATCH_QUEUE_CONCURRENT);
         dispatch_queue_t serialQueue = dispatch_queue_create("serialRunMaxThreadCountWithGCD", DISPATCH_QUEUE_SERIAL);
         // 创建一个semaphore,并设置最大信号量，最大信号量表示最大线程数量
         dispatch_semaphore_t semaphore = dispatch_semaphore_create();
         // 使用循环往串行队列 serialQueue 增加 10 个任务
         for (int i = ; i <  ; i++) {
             dispatch_async(serialQueue, ^{
                 // 只有当信号量大于 0 的时候，线程将信号量减 1，程序向下执行
                 // 否则线程会阻塞并且一直等待，直到信号量大于 0
                 dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
                 dispatch_async(concurrentQueue, ^{
                     NSLog(@"%@ 执行任务一次  i = %d",[NSThread currentThread],i);
                     // 当线程任务执行完成之后，发送一个信号，增加信号量。
                     dispatch_semaphore_signal(semaphore);
                 });
             });
         }
         NSLog(@"%@ 执行任务结束",[NSThread currentThread]);
     }
     
     //执行结果如下，只有 number 3 和 number 4 这 2 个线程在执行
     <nsthread: 0x60c00007c600>{number = , name = main} 执行任务结束
     <nsthread: 0x60c00027a340>{number = , name = (null)} 执行任务一次  i =
     <nsthread: 0x608000263a00>{number = , name = (null)} 执行任务一次  i =
     <nsthread: 0x60c00027a340>{number = , name = (null)} 执行任务一次  i =
     <nsthread: 0x608000263a00>{number = , name = (null)} 执行任务一次  i =
     <nsthread: 0x60c00027a340>{number = , name = (null)} 执行任务一次  i =
     <nsthread: 0x608000263a00>{number = , name = (null)} 执行任务一次  i =
     <nsthread: 0x60c00027a340>{number = , name = (null)} 执行任务一次  i =
     <nsthread: 0x608000263a00>{number = , name = (null)} 执行任务一次  i =
     <nsthread: 0x60c00027a340>{number = , name = (null)} 执行任务一次  i =
     <nsthread: 0x608000263a00>{number = , name = (null)} 执行任务一次  i = 

• GCD队列组：异步执行几个耗时操作，当这几个操作都完成之后再回到主线程进行操作，就可以用到队列组了。GCD 的 dispatch_group_t 功能可以将多个任务分组，等待分组里面的所有任务执行完成之后，GCD 的 dispatch_group_notify 方法可以通知。通常会配合一些常见的场景来考察，比如同时上传 10 张图片，全部上传完成后通知用户。

  // 任务分组
  - (void)runGroupWithGCD
  {
      dispatch_queue_t concurrentQueue = dispatch_queue_create("runGroupWithGCD", DISPATCH_QUEUE_CONCURRENT);
      dispatch_group_t group =  dispatch_group_create();
      for (int i = ; i <  ; i++) {
          dispatch_group_async(group, concurrentQueue, ^{
              NSLog(@"%@ 执行任务一次",[NSThread currentThread]);
          });
      }
      dispatch_group_notify(group, dispatch_get_main_queue(), ^{
          NSLog(@"%@ 执行任务结束",[NSThread currentThread]);
      });
  }
  
  //将所有的任务都加入 group ，等待所有的任务执行完成后，dispatch_group_notify 会被调用。
  <nsthread: 0x608000265180>{number = , name = (null)} 执行任务一次
  <nsthread: 0x604000079a40>{number = , name = (null)} 执行任务一次
  <nsthread: 0x60c000268780>{number = , name = (null)} 执行任务一次
  <nsthread: 0x60c000267dc0>{number = , name = (null)} 执行任务一次
  <nsthread: 0x608000265080>{number = , name = (null)} 执行任务一次
  <nsthread: 0x600000265480>{number = , name = (null)} 执行任务一次
  <nsthread: 0x60c00007f9c0>{number = , name = (null)} 执行任务一次
  <nsthread: 0x608000264f40>{number = , name = (null)} 执行任务一次
  <nsthread: 0x604000079a40>{number = , name = (null)} 执行任务一次
  <nsthread: 0x608000265180>{number = , name = (null)} 执行任务一次
  <nsthread: 0x60000006d180>{number = , name = main} 执行任务结束

队列组有下面几个特点：

1. 所有的任务会并发的执行(不按序)。

2. 所有的异步函数都添加到队列中，然后再纳入队列组的监听范围。

3. 使用dispatch_group_notify函数，来监听上面的任务是否完成，如果完成, 就会调用这个方法。

• GCD 任务分组和线程数量控制：利用 GCD 的 dispatch_group_t 和 semaphore 功能，我们可以做到控制线程数量，并且在所有任务执行完成之后得到通知。

  // 任务分组 + 线程数量控制
  - (void)runMaxCountInGroupWithGCD
  {
      dispatch_queue_t concurrentQueue = dispatch_queue_create("runGroupWithGCD", DISPATCH_QUEUE_CONCURRENT);
      dispatch_group_t group =  dispatch_group_create();
      dispatch_semaphore_t semaphore = dispatch_semaphore_create();
      for (int i = ; i <  ; i++) {
          dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
          dispatch_group_async(group, concurrentQueue, ^{
              NSLog(@"%@ 执行任务一次",[NSThread currentThread]);
              dispatch_semaphore_signal(semaphore);
          });
      }
  
      dispatch_group_notify(group, dispatch_get_main_queue(), ^{
          NSLog(@"%@ 执行任务结束",[NSThread currentThread]);
      });
  }
  
  //执行之后，我们可以看到既控制了线程数量，也在执行任务完成之后得到了通知。
  <nsthread: 0x604000269b40>{number = , name = (null)} 执行任务一次
  <nsthread: 0x608000264780>{number = , name = (null)} 执行任务一次
  <nsthread: 0x604000269b40>{number = , name = (null)} 执行任务一次
  <nsthread: 0x608000264780>{number = , name = (null)} 执行任务一次
  <nsthread: 0x608000264780>{number = , name = (null)} 执行任务一次
  <nsthread: 0x608000264780>{number = , name = (null)} 执行任务一次
  <nsthread: 0x604000269b40>{number = , name = (null)} 执行任务一次
  <nsthread: 0x608000264780>{number = , name = (null)} 执行任务一次
  <nsthread: 0x604000269b40>{number = , name = (null)} 执行任务一次
  <nsthread: 0x60400007aa40>{number = , name = main} 执行任务结束

No.6:GCD使用总结

• 01 异步函数+并发队列：开启多条线程，并发执行任务
• 02 异步函数+串行队列：开启一条线程，串行执行任务
• 03 同步函数+并发队列：不开线程，串行执行任务
• 04 同步函数+串行队列：不开线程，串行执行任务
• 05 异步函数+主队列：不开线程，在主线程中串行执行任务
• 06 同步函数+主队列：不开线程，串行执行任务（注意死锁发生）
• 07 注意同步函数和异步函数在执行顺序上面的差异

七、NSOperation的理解与使用

No.1：NSOperation简介

　　NSOperation是基于GCD之上的更高一层封装，NSOperation需要配合NSOperationQueue来实现多线程。NSOperation实现多线程的步骤如下：

1. 创建任务：先将需要执行的操作封装到NSOperation对象中。

2. 创建队列：创建NSOperationQueue。

3. 将任务加入到队列中：将NSOperation对象添加到NSOperationQueue中。

需要注意的是，NSOperation是个抽象类，实际运用时中需要使用它的子类，有三种方式：

1. 使用子类NSInvocationOperation

2. 使用子类NSBlockOperation

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

No.2：NSOperation的三种创建方式

• NSInvocationOperation的使用：创建NSInvocationOperation对象并关联方法，之后start。

  - (void)testNSInvocationOperation {
      // 创建NSInvocationOperation
      NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperation) object:nil];
      // 开始执行操作
      [invocationOperation start];
  }
  
  - (void)invocationOperation {
      NSLog(@"NSInvocationOperation包含的任务，没有加入队列========%@", [NSThread currentThread]);
  }
  
  //打印结果如下，得到结论：程序在主线程执行，没有开启新线程。这是因为NSOperation多线程的使用需要配合队列NSOperationQueue，后面会讲到NSOperationQueue的使用。
  NSInvocationOperation包含的任务，没有加入队列========{number = , name = main} 

• NSBlockOperation的使用：把任务放到NSBlockOperation的block中，然后start。

  - (void)testNSBlockOperation {
      // 把任务放到block中
      NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
          NSLog(@"NSBlockOperation包含的任务，没有加入队列========%@", [NSThread currentThread]);
      }];
  
      [blockOperation start];
  }
  
  //执行结果如下，可以看出：主线程执行，没有开启新线程。同样的，NSBlockOperation可以配合队列NSOperationQueue来实现多线程。
  NSBlockOperation包含的任务，没有加入队列========{number = , name = main}

但是NSBlockOperation有一个方法addExecutionBlock:，通过这个方法可以让NSBlockOperation实现多线程。

- (void)testNSBlockOperationExecution {
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"NSBlockOperation运用addExecutionBlock主任务========%@", [NSThread currentThread]);
    }];

    [blockOperation addExecutionBlock:^{
        NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务1========%@", [NSThread currentThread]);
    }];
    [blockOperation addExecutionBlock:^{
        NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务2========%@", [NSThread currentThread]);
    }];
    [blockOperation addExecutionBlock:^{
        NSLog(@"NSBlockOperation运用addExecutionBlock方法添加任务3========%@", [NSThread currentThread]);
    }];
    [blockOperation start];
}

//执行结果如下，可以看出，NSBlockOperation创建时block中的任务是在主线程执行，而运用addExecutionBlock加入的任务是在子线程执行的。
NSBlockOperation运用addExecutionBlock========{number = , name = main}
addExecutionBlock方法添加任务1========{number = , name = (null)}
addExecutionBlock方法添加任务3========{number = , name = (null)}
addExecutionBlock方法添加任务2========{number = , name = (null)}

• 运用继承自NSOperation的子类：首先我们定义一个继承自NSOperation的类，然后重写它的main方法，之后就可以使用这个子类来进行相关的操作了。

  /*******************"WHOperation.h"*************************/
  
  #import @interface WHOperation : NSOperation
  
  @end
  /*******************"WHOperation.m"*************************/
  
  #import "WHOperation.h"
  
  @implementation WHOperation
  
  - (void)main {
      for (int i = ; i < ; i++) {
          NSLog(@"NSOperation的子类WHOperation======%@",[NSThread currentThread]);
      }
  }
  
  @end
  
  /*****************回到主控制器使用WHOperation**********************/
  - (void)testWHOperation {
      WHOperation *operation = [[WHOperation alloc] init];
      [operation start];
  }
  
  //输出结果
  SOperation的子类WHOperation======{number = , name = main}
  NSOperation的子类WHOperation======{number = , name = main}
  NSOperation的子类WHOperation======{number = , name = main}

  所以，NSOperation是需要配合队列NSOperationQueue来实现多线程的。下面就来说一下队列NSOperationQueue。

No.3：队列NSOperationQueue

　　NSOperationQueue只有两种队列：主队列、其他队列。其他队列包含了串行和并发。

1. 主队列的创建如下，主队列上的任务是在主线程执行的。

   NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];

2. 其他队列（非主队列）的创建如下，加入到‘非队列’中的任务默认就是并发，开启多线程。

   NSOperationQueue *queue = [[NSOperationQueue alloc] init];

注意：

1. 非主队列（其他队列）可以实现串行或并行。

2. 队列NSOperationQueue有一个参数叫做最大并发数：maxConcurrentOperationCount。

3. maxConcurrentOperationCount默认为-1，直接并发执行，所以加入到‘非队列’中的任务默认就是并发，开启多线程。

4. 当maxConcurrentOperationCount为1时，则表示不开线程，也就是串行。

5. 当maxConcurrentOperationCount大于1时，进行并发执行。

6. 系统对最大并发数有一个限制，所以即使程序员把maxConcurrentOperationCount设置的很大，系统也会自动调整。所以把最大并发数设置的很大是没有意义的。

No.4：NSOperation + NSOperationQueue

　　把任务加入队列，这才是NSOperation的常规使用方式。

• addOperation添加任务到队列：先创建好任务，然后运用- (void)addOperation:(NSOperation *)op 方法来吧任务添加到队列中。

  - (void)testOperationQueue {
      // 创建队列，默认并发
      NSOperationQueue *queue = [[NSOperationQueue alloc] init];
      // 创建操作，NSInvocationOperation
      NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationAddOperation) object:nil];
      // 创建操作，NSBlockOperation
      NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
          for (int i = ; i < ; i++) {
              NSLog(@"addOperation把任务添加到队列======%@", [NSThread currentThread]);
          }
      }];
  
      [queue addOperation:invocationOperation];
      [queue addOperation:blockOperation];
  }
  
  - (void)invocationOperationAddOperation {
      NSLog(@"invocationOperation===aaddOperation把任务添加到队列====%@", [NSThread currentThread]);
  }
  
  //运行结果如下，可以看出，任务都是在子线程执行的，开启了新线程！
  invocationOperation===addOperation把任务添加到队列===={number = , name = (null)}
  addOperation把任务添加到队列======{number = , name = (null)}
  addOperation把任务添加到队列======{number = , name = (null)}
  addOperation把任务添加到队列======{number = , name = (null)}

• addOperationWithBlock添加任务到队列：这是一个更方便的把任务添加到队列的方法，直接把任务写在block中，添加到任务中。

  - (void)testAddOperationWithBlock {
      // 创建队列，默认并发
      NSOperationQueue *queue = [[NSOperationQueue alloc] init];
      // 添加操作到队列
      [queue addOperationWithBlock:^{
          for (int i = ; i < ; i++) {
              NSLog(@"addOperationWithBlock把任务添加到队列======%@", [NSThread currentThread]);
          }
      }];
  }
  
  //运行结果如下，任务确实是在子线程中执行。
  addOperationWithBlock把任务添加到队列======{number = , name = (null)}
  addOperationWithBlock把任务添加到队列======{number = , name = (null)}
  addOperationWithBlock把任务添加到队列======{number = , name = (null)}

• 运用最大并发数实现串行：上面已经说过，可以运用队列的属性maxConcurrentOperationCount（最大并发数）来实现串行，值需要把它设置为1就可以了，下面我们通过代码验证一下。

  - (void)testMaxConcurrentOperationCount {
      // 创建队列，默认并发
      NSOperationQueue *queue = [[NSOperationQueue alloc] init];
      // 最大并发数为1，串行
      queue.maxConcurrentOperationCount = ;
      // 最大并发数为2，并发
  //    queue.maxConcurrentOperationCount = 2;
      // 添加操作到队列
      [queue addOperationWithBlock:^{
          for (int i = ; i < ; i++) {
              NSLog(@"addOperationWithBlock把任务添加到队列1======%@", [NSThread currentThread]);
          }
      }];
      // 添加操作到队列
      [queue addOperationWithBlock:^{
          for (int i = ; i < ; i++) {
              NSLog(@"addOperationWithBlock把任务添加到队列2======%@", [NSThread currentThread]);
          }
      }];
      // 添加操作到队列
      [queue addOperationWithBlock:^{
          for (int i = ; i < ; i++) {
              NSLog(@"addOperationWithBlock把任务添加到队列3======%@", [NSThread currentThread]);
          }
      }];
  }
  
  //运行结果如下，当最大并发数为1的时候，虽然开启了线程，但是任务是顺序执行的，所以实现了串行。
  //你可以尝试把上面的最大并发数变为2，会发现任务就变成了并发执行。
  addOperationWithBlock把任务添加到队列1======{number = , name = (null)}
  addOperationWithBlock把任务添加到队列1======{number = , name = (null)}
  addOperationWithBlock把任务添加到队列1======{number = , name = (null)}
  addOperationWithBlock把任务添加到队列2======{number = , name = (null)}
  addOperationWithBlock把任务添加到队列2======{number = , name = (null)}
  addOperationWithBlock把任务添加到队列2======{number = , name = (null)}
  addOperationWithBlock把任务添加到队列3======{number = , name = (null)}
  addOperationWithBlock把任务添加到队列3======{number = , name = (null)}
  addOperationWithBlock把任务添加到队列3======{number = , name = (null)}

No.5：NSOperation的其他操作

• 取消队列NSOperationQueue的所有操作，NSOperationQueue对象方法，该方法的底层是调用队列中的每个操作的cancel方法，将所有操作取消

  //取消队列里面的所有操作
  //取消之后，当前正在执行的操作的下一个操作将不再执行，而且永远都不在执行，就像后面的所有任务都从队列里面移除了一样
  //取消操作是不可以恢复的
  [self.queue cancelAllOperations]; 

• 取消NSOperation的某个操作，NSOperation对象方法

  - (void)cancel

• 使队列暂停或继续

  //设置暂停和恢复
  //suspended设置为YES表示暂停，suspended设置为NO表示恢复
  //暂停表示不继续执行队列中的下一个任务，暂停操作是可以恢复的
  if (self.queue.isSuspended) {
      self.queue.suspended = NO;
  }else{
      self.queue.suspended = YES;
  }

• 判断队列是否暂停

  - (BOOL)isSuspended

暂停和取消不是立刻取消当前操作，而是等当前的操作执行完之后不再进行新的操作。

No.6：NSOperation的操作依赖

　　NSOperation有一个非常好用的方法，就是操作依赖。可以从字面意思理解：某一个操作（operation2）依赖于另一个操作（operation1），只有当operation1执行完毕，才能执行operation2，这时，就是操作依赖大显身手的时候了。

- (void)testAddDependency {

    // 并发队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 操作1
    NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = ; i < ; i++) {
            NSLog(@"operation1======%@", [NSThread  currentThread]);
        }
    }];

    // 操作2
    NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"****operation2依赖于operation1，只有当operation1执行完毕，operation2才会执行****");
        for (int i = ; i < ; i++) {
            NSLog(@"operation2======%@", [NSThread  currentThread]);
        }
    }];

    // 使操作2依赖于操作1
    [operation2 addDependency:operation1];
    // 把操作加入队列
    [queue addOperation:operation1];
    [queue addOperation:operation2];
}

//运行结果如下，操作2总是在操作1之后执行，成功验证了上面的说法。
operation1======{number = , name = (null)}
operation1======{number = , name = (null)}
operation1======{number = , name = (null)}
****operation2依赖于operation1，只有当operation1执行完毕，operation2才会执行****
operation2======{number = , name = (null)}
operation2======{number = , name = (null)}
operation2======{number = , name = (null)}

后记

• 本文所述的示例代码在这里：WHMultiThreadDemo