关于iOS多线程，你看我就够了

时间 2019-11-30

标签关于 ios 多线程够了栏目 iOS 繁體版

原文原文链接

在这篇文章中，我将为你整理一下 iOS 开发中几种多线程方案，以及其使用方法和注意事项。固然也会给出几种多线程的案例，在实际使用中感觉它们的区别。还有一点须要说明的是，这篇文章将会使用 Swift 和 Objective-c 两种语言讲解，双语幼儿园。OK，let's begin!

概述

这篇文章中，我不会说多线程是什么、线程和进程的区别、多线程有什么用，固然我也不会说什么是串行、什么是并行等问题，这些咱们应该都知道的。面试

在 iOS 中其实目前有 4 套多线程方案，他们分别是：objective-c

Pthreads

NSThread

GCD

NSOperation & NSOperationQueue

因此接下来，我会一一讲解这些方案的使用方法和一些案例。在将这些内容的时候，我也会顺带说一些多线程周边产品。好比： 线程同步、 延时执行、 单例模式 等等。算法

Pthreads

其实这个方案不用说的，只是拿来充个数，为了让你们了解一下就行了。百度百科里是这么说的：swift

POSIX线程（POSIX threads），简称Pthreads，是线程的POSIX标准。该标准定义了建立和操纵线程的一整套API。在类Unix操做系统（Unix、Linux、Mac OS X等）中，都使用Pthreads做为操做系统的线程。

简单地说，这是一套在不少操做系统上都通用的多线程API，因此移植性很强（然并卵），固然在 iOS 中也是能够的。不过这是基于 c语言 的框架，使用起来这酸爽！感觉一下：api

OBJECTIVE-C

固然第一步要包含头文件xcode

#import <pthread.h>

而后建立线程，并执行任务安全

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
    pthread_t thread;
    //建立一个线程并自动执行
    pthread_create(&thread, NULL, start, NULL);
}

void *start(void *data) {
    NSLog(@"%@", [NSThread currentThread]);

    return NULL;
}复制代码

打印输出：bash

2015-07-27 23:57:21.689 testThread[10616:2644653] <NSThread: 0x7fbb48d33690>{number = 2, name = (null)}

看代码就会发现他须要 c语言函数，这是比较蛋疼的，更蛋疼的是你须要手动处理线程的各个状态的转换即管理生命周期，好比，这段代码虽然建立了一个线程，但并无销毁。服务器

SWIFT

很遗憾，在我目前的 swift1.2 中没法执行这套方法，缘由是这个函数须要传入一个函数指针 CFunctionPointer<T> 类型，可是目前 swift 没法将方法转换成此类型。据说 swift 2.0 引入一个新特性 @convention(c), 能够完成 Swift 方法转换成 c 语言指针的。在这里能够看到微信

那么，Pthreads 方案的多线程我就介绍这么多，毕竟作 iOS 开发几乎不可能用到。可是若是你感兴趣的话，或者说想要本身实现一套多线程方案，从底层开始定制，那么能够去搜一下相关资料。

NSThread

这套方案是通过苹果封装后的，而且彻底面向对象的。因此你能够直接操控线程对象，很是直观和方便。可是，它的生命周期仍是须要咱们手动管理，因此这套方案也是偶尔用用，好比 [NSThread currentThread]，它能够获取当前线程类，你就能够知道当前线程的各类属性，用于调试十分方便。下面来看看它的一些用法。

建立并启动

先建立线程类，再启动

OBJECTIVE-C

// 建立
  NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run:) object:nil];

  // 启动
  [thread start];复制代码

SWIFT

//建立
  let thread = NSThread(target: self, selector: "run:", object: nil)

  //启动
  thread.start()复制代码

建立并自动启动

OBJECTIVE-C

[NSThread detachNewThreadSelector:@selector(run:) toTarget:self withObject:nil];复制代码

SWIFT

NSThread.detachNewThreadSelector("run:", toTarget: self, withObject: nil)复制代码

使用 NSObject 的方法建立并自动启动

OBJECTIVE-C
```
[self performSelectorInBackground:@selector(run:) withObject:nil];复制代码
```
SWIFT

很遗憾 too! 苹果认为 performSelector: 不安全，因此在 Swift 去掉了这个方法。

Note: The performSelector: method and related selector-invoking methods are not imported in Swift because they are inherently unsafe.

其余方法

除了建立启动外，NSThread 还以不少方法，下面我列举一些常见的方法，固然我列举的并不完整，更多方法你们能够去类的定义里去看。

OBJECTIVE-C

//取消线程
- (void)cancel;

//启动线程
- (void)start;

//判断某个线程的状态的属性
@property (readonly, getter=isExecuting) BOOL executing;
@property (readonly, getter=isFinished) BOOL finished;
@property (readonly, getter=isCancelled) BOOL cancelled;

//设置和获取线程名字
-(void)setName:(NSString *)n;
-(NSString *)name;

//获取当前线程信息
+ (NSThread *)currentThread;

//获取主线程信息
+ (NSThread *)mainThread;

//使当前线程暂停一段时间，或者暂停到某个时刻
+ (void)sleepForTimeInterval:(NSTimeInterval)time;
+ (void)sleepUntilDate:(NSDate *)date;复制代码

SWIFT

Swift的方法名字和OC的方法名都同样，我就不浪费空间列举出来了。

其实，NSThread 用起来也挺简单的，由于它就那几种方法。同时，咱们也只有在一些很是简单的场景才会用 NSThread, 毕竟它还不够智能，不能优雅地处理多线程中的其余高级概念。因此接下来要说的内容才是重点。

GCD

Grand Central Dispatch，听名字就霸气。它是苹果为多核的并行运算提出的解决方案，因此会自动合理地利用更多的CPU内核（好比双核、四核），最重要的是它会自动管理线程的生命周期（建立线程、调度任务、销毁线程），彻底不须要咱们管理，咱们只须要告诉干什么就行。同时它使用的也是 c语言，不过因为使用了 Block（Swift里叫作闭包），使得使用起来更加方便，并且灵活。因此基本上你们都使用 GCD 这套方案，老小咸宜，实在是居家旅行、杀人灭口，必备良药。很差意思，有点中二，我们继续。

任务和队列

在 GCD 中，加入了两个很是重要的概念：任务和队列。

任务：即操做，你想要干什么，说白了就是一段代码，在 GCD 中就是一个 Block，因此添加任务十分方便。任务有两种执行方式： 同步执行 和 异步执行，他们之间的区别是 是否会建立新的线程。

同步执行：

只要是同步执行的任务，都会在当前线程执行，不会另开线程。

异步执行：

只要是异步执行的任务，都会另开线程，在别的线程执行。

更新：
这里说的并不许确，同步（sync） 和 异步（async） 的主要区别在于会不会阻塞当前线程，直到 Block 中的任务执行完毕！
若是是 同步（sync） 操做，它会阻塞当前线程并等待 Block 中的任务执行完毕，而后当前线程才会继续往下运行。
若是是 异步（async）操做，当前线程会直接往下执行，它不会阻塞当前线程。
队列：用于存听任务。一共有两种队列， 串行队列 和 并行队列。

串行队列 中的任务会根据队列的定义 FIFO 的执行，一个接一个的先进先出的进行执行。

更新：放到串行队列的任务，GCD 会 FIFO（先进先出） 地取出来一个，执行一个，而后取下一个，这样一个一个的执行。

并行队列 中的任务

根据同步或异步有不一样的执行方式。

更新：放到并行队列的任务，GCD 也会 FIFO的取出来，但不一样的是，它取出来一个就会放到别的线程，而后再取出来一个又放到另外一个的线程。这样因为取的动做很快，忽略不计，看起来，全部的任务都是一块儿执行的。不过须要注意，GCD 会根据系统资源控制并行的数量，因此若是任务不少，它并不会让全部任务同时执行。

虽然很绕，但请看下表：

	同步执行	异步执行
串行队列	当前线程，一个一个执行	其余线程，一个一个执行
并行队列	当前线程，一个一个执行	开不少线程，一块儿执行

建立队列

主队列：这是一个特殊的 串行队列。什么是主队列，你们都知道吧，它用于刷新 UI，任何须要刷新 UI 的工做都要在主队列执行，因此通常耗时的任务都要放到别的线程执行。
```
//OBJECTIVE-C
  dispatch_queue_t queue = ispatch_get_main_queue();

  //SWIFT
  let queue = ispatch_get_main_queue()复制代码
```
本身建立的队列：

凡是本身建立的队列都是 串行队列。
其中第一个参数是标识符，用于 DEBUG 的时候标识惟一的队列，能够为空。你们能够看xcode的文档查看参数意义。

更新：本身能够建立 串行队列, 也能够建立 并行队列。看下面的代码（代码已更新），它有两个参数，第一个上面已经说了，第二个才是最重要的。
第二个参数用来表示建立的队列是串行的仍是并行的，传入 DISPATCH_QUEUE_SERIAL 或 NULL 表示建立串行队列。传入 DISPATCH_QUEUE_CONCURRENT 表示建立并行队列。

//OBJECTIVE-C
  //串行队列
  dispatch_queue_t queue = dispatch_queue_create("tk.bourne.testQueue", NULL);
  dispatch_queue_t queue = dispatch_queue_create("tk.bourne.testQueue", DISPATCH_QUEUE_SERIAL);
  //并行队列
  dispatch_queue_t queue = dispatch_queue_create("tk.bourne.testQueue", DISPATCH_QUEUE_CONCURRENT);

  //SWIFT
  //串行队列
  let queue = dispatch_queue_create("tk.bourne.testQueue", nil);
  let queue = dispatch_queue_create("tk.bourne.testQueue", DISPATCH_QUEUE_SERIAL)
  //并行队列
  let queue = dispatch_queue_create("tk.bourne.testQueue", DISPATCH_QUEUE_CONCURRENT)复制代码

全局并行队列：

这应该是惟一一个并行队列，

只要是并行任务通常都加入到这个队列。这是系统提供的一个并发队列。

//OBJECTIVE-C
  dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

  //SWIFT
  let queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)复制代码

建立任务

同步任务：

不会另开线程

改：会阻塞当前线程 (SYNC)

OBJECTIVE-C

dispatch_sync(<#queue#>, ^{
      //code here
      NSLog(@"%@", [NSThread currentThread]);
  });复制代码

SWIFT

dispatch_sync(<#queue#>, { () -> Void in
      //code here
      println(NSThread.currentThread())
  })复制代码

异步任务：

会另开线程

改：不会阻塞当前线程 (ASYNC)

OBJECTIVE-C

dispatch_async(<#queue#>, ^{
      //code here
      NSLog(@"%@", [NSThread currentThread]);
  });复制代码

SWIFT

dispatch_async(<#queue#>, { () -> Void in
      //code here
      println(NSThread.currentThread())
  })复制代码

更新：
为了更好的理解同步和异步，和各类队列的使用，下面看两个示例：

示例一：
如下代码在主线程调用，结果是什么？

NSLog("以前 - %@", NSThread.currentThread())
dispatch_sync(dispatch_get_main_queue(), { () -> Void in 
        NSLog("sync - %@", NSThread.currentThread())
})
NSLog("以后 - %@", NSThread.currentThread())复制代码

答案：
只会打印第一句：以前 - <NSThread: 0x7fb3a9e16470>{number = 1, name = main} ，而后主线程就卡死了，你能够在界面上放一个按钮，你就会发现点不了了。
解释：
同步任务会阻塞当前线程，而后把 Block 中的任务放到指定的队列中执行，只有等到 Block 中的任务完成后才会让当前线程继续往下运行。
那么这里的步骤就是：打印完第一句后，dispatch_sync 当即阻塞当前的主线程，而后把 Block 中的任务放到 main_queue 中，但是 main_queue 中的任务会被取出来放到主线程中执行，但主线程这个时候已经被阻塞了，因此 Block 中的任务就不能完成，它不完成，dispatch_sync 就会一直阻塞主线程，这就是死锁现象。致使主线程一直卡死。

示例二：
如下代码会产生什么结果？
let queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_SERIAL)复制代码

NSLog("以前 - %@", NSThread.currentThread())

dispatch_async(queue, { () -> Void in
    NSLog("sync以前 - %@", NSThread.currentThread())
    dispatch_sync(queue, { () -> Void in
         NSLog("sync - %@", NSThread.currentThread())
    })
    NSLog("sync以后 - %@", NSThread.currentThread())复制代码

})

NSLog("以后 - %@", NSThread.currentThread())

**答案：**
2015-07-30 02:06:51.058 test[33329:8793087] 以前 - <NSThread: 0x7fe32050dbb0>{number = 1, name = main}
2015-07-30 02:06:51.059 test[33329:8793356] sync以前 - <NSThread: 0x7fe32062e9f0>{number = 2, name = (null)}
2015-07-30 02:06:51.059 test[33329:8793087] 以后 - <NSThread: 0x7fe32050dbb0>{number = 1, name = main}
很明显 `sync - %@` 和 `sync以后 - %@` 没有被打印出来！这是为何呢？咱们再来分析一下：

>**分析：**
咱们按执行顺序一步步来哦：
1. 使用 `DISPATCH_QUEUE_SERIAL` 这个参数，建立了一个 **串行队列**。
2. 打印出 `以前 - %@` 这句。
3. `dispatch_async` 异步执行，因此当前线程不会被阻塞，因而有了两条线程，一条当前线程继续往下打印出 `以后 - %@`这句, 另外一台执行 Block 中的内容打印 `sync以前 - %@` 这句。由于这两条是并行的，因此打印的前后顺序无所谓。
4. 注意，高潮来了。如今的状况和上一个例子同样了。`dispatch_sync`同步执行，因而它所在的线程会被阻塞，一直等到 `sync` 里的任务执行完才会继续往下。因而 `sync` 就高兴的把本身 Block 中的任务放到 `queue` 中，可谁想 `queue` 是一个串行队列，一次执行一个任务，因此 `sync` 的 Block 必须等到前一个任务执行完毕，可万万没想到的是 `queue` 正在执行的任务就是被 `sync` 阻塞了的那个。因而又发生了死锁。因此 `sync` 所在的线程被卡死了。剩下的两句代码天然不会打印。 


### 队列组

队列组能够将不少队列添加到一个组里，这样作的好处是，当这个组里全部的任务都执行完了，队列组会经过一个方法通知咱们。下面是使用方法，这是一个很实用的功能。

###### OBJECTIVE-C

``` objective-c
//1.建立队列组
dispatch_group_t group = dispatch_group_create();
//2.建立队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

//3.屡次使用队列组的方法执行任务, 只有异步方法
//3.1.执行3次循环
dispatch_group_async(group, queue, ^{
   for (NSInteger i = 0; i < 3; i++) {
       NSLog(@"group-01 - %@", [NSThread currentThread]);
   }
});

//3.2.主队列执行8次循环
dispatch_group_async(group, dispatch_get_main_queue(), ^{
   for (NSInteger i = 0; i < 8; i++) {
       NSLog(@"group-02 - %@", [NSThread currentThread]);
   }
});

//3.3.执行5次循环
dispatch_group_async(group, queue, ^{
   for (NSInteger i = 0; i < 5; i++) {
       NSLog(@"group-03 - %@", [NSThread currentThread]);
   }
});

//4.都完成后会自动通知
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
   NSLog(@"完成 - %@", [NSThread currentThread]);
});复制代码

SWIFT

//1.建立队列组
let group = dispatch_group_create()
//2.建立队列
let queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)

//3.屡次使用队列组的方法执行任务, 只有异步方法
//3.1.执行3次循环
dispatch_group_async(group, queue) { () -> Void in
    for _ in 0..<3 {
        NSLog("group-01 - %@", NSThread.currentThread())
    }
}

//3.2.主队列执行8次循环
dispatch_group_async(group, dispatch_get_main_queue()) { () -> Void in
    for _ in 0..<8 {
        NSLog("group-02 - %@", NSThread.currentThread())
    }
}

//3.3.执行5次循环
dispatch_group_async(group, queue) { () -> Void in
    for _ in 0..<5 {
        NSLog("group-03 - %@", NSThread.currentThread())
    }
}

//4.都完成后会自动通知
dispatch_group_notify(group, dispatch_get_main_queue()) { () -> Void in
    NSLog("完成 - %@", NSThread.currentThread())
}复制代码

打印结果

2015-07-28 03:40:34.277 test[12540:3319271] group-03 - <NSThread: 0x7f9772536f00>{number = 3, name = (null)}

2015-07-28 03:40:34.277 test[12540:3319146] group-02 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.277 test[12540:3319146] group-02 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.277 test[12540:3319271] group-03 - <NSThread: 0x7f9772536f00>{number = 3, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319146] group-02 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.278 test[12540:3319271] group-03 - <NSThread: 0x7f9772536f00>{number = 3, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319271] group-03 - <NSThread: 0x7f9772536f00>{number = 3, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319146] group-02 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.277 test[12540:3319273] group-01 - <NSThread: 0x7f977272e8d0>{number = 2, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319271] group-03 - <NSThread: 0x7f9772536f00>{number = 3, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319146] group-02 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.278 test[12540:3319273] group-01 - <NSThread: 0x7f977272e8d0>{number = 2, name = (null)}

2015-07-28 03:40:34.278 test[12540:3319146] group-02 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.278 test[12540:3319273] group-01 - <NSThread: 0x7f977272e8d0>{number = 2, name = (null)}

2015-07-28 03:40:34.279 test[12540:3319146] group-02 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.279 test[12540:3319146] group-02 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

2015-07-28 03:40:34.279 test[12540:3319146] 完成 - <NSThread: 0x7f977240ba60>{number = 1, name = main}

这些就是 GCD 的基本功能，可是它的能力远不止这些，等讲完 NSOperation 后，咱们再来看看它的一些其余方面用途。并且，只要你想象力够丰富，你能够组合出更好的用法。

更新：关于GCD，还有两个须要说的：

func dispatch_barrier_async(_ queue: dispatch_queue_t, _ block: dispatch_block_t):
这个方法重点是你传入的 queue，当你传入的 queue 是经过 DISPATCH_QUEUE_CONCURRENT 参数本身建立的 queue 时，这个方法会阻塞这个 queue（注意是阻塞 queue ，而不是阻塞当前线程），一直等到这个 queue 中排在它前面的任务都执行完成后才会开始执行本身，本身执行完毕后，再会取消阻塞，使这个 queue 中排在它后面的任务继续执行。
若是你传入的是其余的 queue, 那么它就和 dispatch_async 同样了。

func dispatch_barrier_sync(_ queue: dispatch_queue_t, _ block: dispatch_block_t):
这个方法的使用和上一个同样，传入 自定义的并发队列（DISPATCH_QUEUE_CONCURRENT），它和上一个方法同样的阻塞 queue，不一样的是这个方法还会 阻塞当前线程。
若是你传入的是其余的 queue, 那么它就和 dispatch_sync 同样了。

NSOperation和NSOperationQueue

NSOperation 是苹果公司对 GCD 的封装，彻底面向对象，因此使用起来更好理解。你们能够看到 NSOperation 和 NSOperationQueue 分别对应 GCD 的 任务和队列 。操做步骤也很好理解：

将要执行的任务封装到一个 NSOperation 对象中。
将此任务添加到一个 NSOperationQueue 对象中。

而后系统就会自动在执行任务。至于同步仍是异步、串行仍是并行请继续往下看：

添加任务

值得说明的是，NSOperation 只是一个抽象类，因此不能封装任务。但它有 2 个子类用于封装任务。分别是：NSInvocationOperation 和 NSBlockOperation 。建立一个 Operation 后，须要调用 start 方法来启动任务，它会 默认在当前队列同步执行。固然你也能够在中途取消一个任务，只须要调用其 cancel 方法便可。

NSInvocationOperation : 须要传入一个方法名。

OBJECTIVE-C

//1.建立NSInvocationOperation对象
  NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];

  //2.开始执行
  [operation start];复制代码

SWIFT

在 Swift 构建的和谐社会里，是容不下 NSInvocationOperation 这种不是类型安全的败类的。苹果如是说。这里有相关解释

NSBlockOperation

OBJECTIVE-C
```
//1.建立NSBlockOperation对象
  NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
      NSLog(@"%@", [NSThread currentThread]);
  }];

  //2.开始任务
  [operation start];复制代码
```
SWIFT
```
//1.建立NSBlockOperation对象
  let operation = NSBlockOperation { () -> Void in
      println(NSThread.currentThread())
  }

  //2.开始任务
  operation.start()复制代码
```
以前说过这样的任务，默认会在当前线程执行。可是 NSBlockOperation 还有一个方法：addExecutionBlock: ，经过这个方法能够给 Operation 添加多个执行 Block。这样 Operation 中的任务 会并发执行，它会 在主线程和其它的多个线程 执行这些任务，注意下面的打印结果：

OBJECTIVE-C
```
//1.建立NSBlockOperation对象
      NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
          NSLog(@"%@", [NSThread currentThread]);
      }];

      //添加多个Block
      for (NSInteger i = 0; i < 5; i++) {
          [operation addExecutionBlock:^{
              NSLog(@"第%ld次：%@", i, [NSThread currentThread]);
          }];
      }

      //2.开始任务
      [operation start];复制代码
```
SWIFT
```
//1.建立NSBlockOperation对象
        let operation = NSBlockOperation { () -> Void in
            NSLog("%@", NSThread.currentThread())
        }

        //2.添加多个Block
        for i in 0..<5 {
            operation.addExecutionBlock { () -> Void in
                NSLog("第%ld次 - %@", i, NSThread.currentThread())
            }
        }

        //2.开始任务
        operation.start()复制代码
```
打印输出

2015-07-28 17:50:16.585 test[17527:4095467] 第2次 - <NSThread: 0x7ff5c9701910>{number = 1, name = main}

2015-07-28 17:50:16.585 test[17527:4095666] 第1次 - <NSThread: 0x7ff5c972caf0>{number = 4, name = (null)}

2015-07-28 17:50:16.585 test[17527:4095665] <NSThread: 0x7ff5c961b610>{number = 3, name = (null)}

2015-07-28 17:50:16.585 test[17527:4095662] 第0次 - <NSThread: 0x7ff5c948d310>{number = 2, name = (null)}

2015-07-28 17:50:16.586 test[17527:4095666] 第3次 - <NSThread: 0x7ff5c972caf0>{number = 4, name = (null)}

2015-07-28 17:50:16.586 test[17527:4095467] 第4次 - <NSThread: 0x7ff5c9701910>{number = 1, name = main}

NOTE：addExecutionBlock 方法必须在 start() 方法以前执行，不然就会报错：

‘*** -[NSBlockOperation addExecutionBlock:]: blocks cannot be added after the operation has started executing or finished'

NOTE：你们可能发现了一个问题，为何我在 Swift 里打印输出使用 NSLog() 而不是 println() 呢？缘由是使用 print() / println() 输出的话，它会简单地使用 流（stream） 的概念，学过 C++ 的都知道。它会把须要输出的每一个字符一个一个的输出到控制台。普通使用并无问题，但是当多线程同步输出的时候问题就来了，因为不少 println() 同时打印，就会致使控制台上的字符混乱的堆在一块儿，而NSLog() 就没有这个问题。究竟是什么样子的呢？你能够把上面 NSLog() 改成 println() ，而后一试便知。更多 NSLog() 与 println() 的区别看这里

自定义Operation

除了上面的两种 Operation 之外，咱们还能够自定义 Operation。自定义 Operation 须要继承 NSOperation 类，并实现其 main() 方法，由于在调用 start() 方法的时候，内部会调用 main() 方法完成相关逻辑。因此若是以上的两个类没法知足你的欲望的时候，你就须要自定义了。你想要实现什么功能均可以写在里面。除此以外，你还须要实现 cancel() 在内的各类方法。因此这个功能提供给高级玩家，我在这里就不说了，等我须要用到时在研究它，到时候可能会再作更新。

建立队列

看过上面的内容就知道，咱们能够调用一个 NSOperation 对象的 start() 方法来启动这个任务，可是这样作他们默认是 同步执行 的。就算是 addExecutionBlock 方法，也会在 当前线程和其余线程 中执行，也就是说仍是会占用当前线程。这是就要用到队列 NSOperationQueue 了。并且，按类型来讲的话一共有两种类型：主队列、其余队列。只要添加到队列，会自动调用任务的 start() 方法

主队列

细心的同窗就会发现，每套多线程方案都会有一个主线程（固然啦，说的是iOS中，像 pthread 这种多系统的方案并无，由于 UI线程 理论须要每种操做系统本身定制）。这是一个特殊的线程，必须串行。因此添加到主队列的任务都会一个接一个地排着队在主线程处理。
```
//OBJECTIVE-C
NSOperationQueue *queue = [NSOperationQueue mainQueue];

//SWIFT
let queue = NSOperationQueue.mainQueue()复制代码
```

其余队列

由于主队列比较特殊，因此会单独有一个类方法来得到主队列。那么经过初始化产生的队列就是其余队列了，由于只有这两种队列，除了主队列，其余队列就不须要名字了。

注意：其余队列的任务会在其余线程并行执行。

OBJECTIVE-C
```
//1.建立一个其余队列 
NSOperationQueue *queue = [[NSOperationQueue alloc] init];

//2.建立NSBlockOperation对象
NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"%@", [NSThread currentThread]);
}];

//3.添加多个Block
for (NSInteger i = 0; i < 5; i++) {
    [operation addExecutionBlock:^{
        NSLog(@"第%ld次：%@", i, [NSThread currentThread]);
    }];
}

//4.队列添加任务
[queue addOperation:operation];复制代码
```
SWIFT
```
//1.建立其余队列
let queue = NSOperationQueue()

//2.建立NSBlockOperation对象
let operation = NSBlockOperation { () -> Void in
    NSLog("%@", NSThread.currentThread())
}

//3.添加多个Block
for i in 0..<5 {
    operation.addExecutionBlock { () -> Void in
        NSLog("第%ld次 - %@", i, NSThread.currentThread())
    }
}

//4.队列添加任务
queue.addOperation(operation)复制代码
```
打印输出

2015-07-28 20:26:28.463 test[18622:4443534] <NSThread: 0x7fd022c3ac10>{number = 5, name = (null)}

2015-07-28 20:26:28.463 test[18622:4443536] 第2次 - <NSThread: 0x7fd022e36d50>{number = 2, name = (null)}

2015-07-28 20:26:28.463 test[18622:4443535] 第0次 - <NSThread: 0x7fd022f237f0>{number = 4, name = (null)}

2015-07-28 20:26:28.463 test[18622:4443533] 第1次 - <NSThread: 0x7fd022d372b0>{number = 3, name = (null)}

2015-07-28 20:26:28.463 test[18622:4443534] 第3次 - <NSThread: 0x7fd022c3ac10>{number = 5, name = (null)}

2015-07-28 20:26:28.463 test[18622:4443536] 第4次 - <NSThread: 0x7fd022e36d50>{number = 2, name = (null)}

OK, 这时应该发问了，你们将 NSOperationQueue 与 GCD的队列 相比较就会发现，这里没有串行队列，那若是我想要10个任务在其余线程串行的执行怎么办？

这就是苹果封装的妙处，你不用管串行、并行、同步、异步这些名词。NSOperationQueue 有一个参数 maxConcurrentOperationCount 最大并发数，用来设置最多可让多少个任务同时执行。当你把它设置为 1 的时候，他不就是串行了嘛！

NSOperationQueue 还有一个添加任务的方法，- (void)addOperationWithBlock:(void (^)(void))block; ，这是否是和 GCD 差很少？这样就能够添加一个任务到队列中了，十分方便。

NSOperation 有一个很是实用的功能，那就是添加依赖。好比有 3 个任务：A: 从服务器上下载一张图片，B：给这张图片加个水印，C：把图片返回给服务器。这时就能够用到依赖了:

OBJECTIVE-C

//1.任务一：下载图片
NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"下载图片 - %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:1.0];
}];

//2.任务二：打水印
NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"打水印 - %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:1.0];
}];

//3.任务三：上传图片
NSBlockOperation *operation3 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"上传图片 - %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:1.0];
}];

//4.设置依赖
[operation2 addDependency:operation1];      //任务二依赖任务一
[operation3 addDependency:operation2];      //任务三依赖任务二

//5.建立队列并加入任务
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperations:@[operation3, operation2, operation1] waitUntilFinished:NO];复制代码

SWIFT

//1.任务一：下载图片
let operation1 = NSBlockOperation { () -> Void in
    NSLog("下载图片 - %@", NSThread.currentThread())
    NSThread.sleepForTimeInterval(1.0)
}

//2.任务二：打水印
let operation2 = NSBlockOperation { () -> Void in
    NSLog("打水印 - %@", NSThread.currentThread())
    NSThread.sleepForTimeInterval(1.0)
}

//3.任务三：上传图片
let operation3 = NSBlockOperation { () -> Void in
    NSLog("上传图片 - %@", NSThread.currentThread())
    NSThread.sleepForTimeInterval(1.0)
}

//4.设置依赖
operation2.addDependency(operation1)    //任务二依赖任务一
operation3.addDependency(operation2)    //任务三依赖任务二

//5.建立队列并加入任务
let queue = NSOperationQueue()
queue.addOperations([operation3, operation2, operation1], waitUntilFinished: false)复制代码

打印结果

2015-07-28 21:24:28.622 test[19392:4637517] 下载图片 - <NSThread: 0x7fc10ad4d970>{number = 2, name = (null)}

2015-07-28 21:24:29.622 test[19392:4637515] 打水印 - <NSThread: 0x7fc10af20ef0>{number = 3, name = (null)}

2015-07-28 21:24:30.627 test[19392:4637515] 上传图片 - <NSThread: 0x7fc10af20ef0>{number = 3, name = (null)}

注意：不能添加相互依赖，会死锁，好比 A依赖B，B依赖A。
可使用 removeDependency 来解除依赖关系。
能够在不一样的队列之间依赖，反正就是这个依赖是添加到任务身上的，和队列不要紧。

其余方法

以上就是一些主要方法, 下面还有一些经常使用方法须要你们注意：

NSOperation

BOOL executing; //判断任务是否正在执行

BOOL finished; //判断任务是否完成

void (^completionBlock)(void); //用来设置完成后须要执行的操做

- (void)cancel; //取消任务

- (void)waitUntilFinished; //阻塞当前线程直到此任务执行完毕
NSOperationQueue

NSUInteger operationCount; //获取队列的任务数

- (void)cancelAllOperations; //取消队列中全部的任务

- (void)waitUntilAllOperationsAreFinished; //阻塞当前线程直到此队列中的全部任务执行完毕

[queue setSuspended:YES]; // 暂停queue

[queue setSuspended:NO]; // 继续queue

好啦，到这里差很少就讲完了。固然，我讲的并不完整，可能有一些知识我并无讲到，但做为经常使用方法，这些已经足够了。不过我在这里只是告诉你了一些方法的功能，只是怎么把他们用到合适的地方，就须要多多实践了。下面我会说一些关于多线程的案例，是你们更加什么地了解。

其余用法

在这部分，我会说一些和多线程知识相关的案例，可能有些很简单，你们早都知道的，不过由于这篇文章讲的是多线程嘛，因此应该尽量的全面嘛。还有就是，我会尽量的使用多种方法实现，让你们看看其中的区别。

线程同步

所谓线程同步就是为了防止多个线程抢夺同一个资源形成的数据安全问题，所采起的一种措施。固然也有不少实现方法，请往下看：

互斥锁 ：给须要同步的代码块加一个互斥锁，就能够保证每次只有一个线程访问此代码块。

OBJECTIVE-C

@synchronized(self) {
  //须要执行的代码块
}复制代码

SWIFT

objc_sync_enter(self)
//须要执行的代码块
objc_sync_exit(self)复制代码

同步执行 ：咱们可使用多线程的知识，把多个线程都要执行此段代码添加到同一个串行队列，这样就实现了线程同步的概念。固然这里可使用 GCD 和 NSOperation 两种方案，我都写出来。

OBJECTIVE-C

//GCD
//须要一个全局变量queue，要让全部线程的这个操做都加到一个queue中
dispatch_sync(queue, ^{
    NSInteger ticket = lastTicket;
    [NSThread sleepForTimeInterval:0.1];
    NSLog(@"%ld - %@",ticket, [NSThread currentThread]);
    ticket -= 1;
    lastTicket = ticket;
});


//NSOperation & NSOperationQueue
//重点：1. 全局的 NSOperationQueue, 全部的操做添加到同一个queue中
// 2. 设置 queue 的 maxConcurrentOperationCount 为 1
// 3. 若是后续操做须要Block中的结果，就须要调用每一个操做的waitUntilFinished，阻塞当前线程，一直等到当前操做完成，才容许执行后面的。waitUntilFinished 要在添加到队列以后！

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
    NSInteger ticket = lastTicket;
    [NSThread sleepForTimeInterval:1];
    NSLog(@"%ld - %@",ticket, [NSThread currentThread]);
    ticket -= 1;
    lastTicket = ticket;
}];

[queue addOperation:operation];

[operation waitUntilFinished];

//后续要作的事复制代码

SWIFT

这里的 swift 代码，我就不写了，由于每句都同样，只是语法不一样而已，照着 OC 的代码就能写出 Swift 的。这篇文章已经老长老长了，我就不浪费篇幅了，又不是高中写做文。

延迟执行

所谓延迟执行就是延时一段时间再执行某段代码。下面说一些经常使用方法。

perform

OBJECTIVE-C

// 3秒后自动调用self的run:方法，而且传递参数：@"abc"
[self performSelector:@selector(run:) withObject:@"abc" afterDelay:3];复制代码

SWIFT

以前就已经说过，Swift 里去掉了这个方法。复制代码

GCD

可使用 GCD 中的 dispatch_after 方法，OC 和 Swift 均可以使用，这里只写 OC 的，Swift 的是同样的。

OBJECTIVE-C

// 建立队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 设置延时，单位秒
double delay = 3; 

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delay * NSEC_PER_SEC)), queue, ^{
  // 3秒后须要执行的任务
});复制代码

NSTimer

NSTimer 是iOS中的一个计时器类，除了延迟执行还有不少用法，不过这里直说延迟执行的用法。一样只写 OC 版的，Swift 也是相同的。

OBJECTIVE-C
```
[NSTimer scheduledTimerWithTimeInterval:3.0 target:self selector:@selector(run:) userInfo:@"abc" repeats:NO];复制代码
```

单例模式

至于什么是单例模式，我也很少说，我只说说通常怎么实现。在 Objective-C 中，实现单例的方法已经很具体了，虽然有别的方法，可是通常都是用一个标准的方法了，下面来看看。

OBJECTIVE-C

@interface Tool : NSObject <NSCopying>

+ (instancetype)sharedTool;

@end

@implementation Tool

static id _instance;

+ (instancetype)sharedTool {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _instance = [[Tool alloc] init];
    });

    return _instance;
}

@end复制代码

这里之因此将单例模式，是由于其中用到了 GCD 的 dispatch_once 方法。下面看 Swift 中的单例模式，在Swift中单例模式很是简单！想知道怎么从 OC 那么复杂的方法变成下面的写法的，请看这里

SWIFT

class Tool: NSObject {
    static let sharedTool = Tool()

    // 私有化构造方法，阻止其余对象使用这个类的默认的'()'构造方法
    private override init() {}
}复制代码

从其余线程回到主线程的方法

咱们都知道在其余线程操做完成后必须到主线程更新UI。因此，介绍完全部的多线程方案后，咱们来看看有哪些方法能够回到主线程。

NSThread

//Objective-C
[self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:NO];

//Swift
//swift 取消了 performSelector 方法。复制代码

GCD

//Objective-C
dispatch_async(dispatch_get_main_queue(), ^{

});

//Swift
dispatch_async(dispatch_get_main_queue(), { () -> Void in

})复制代码

NSOperationQueue

//Objective-C
[[NSOperationQueue mainQueue] addOperationWithBlock:^{

}];

//Swift
NSOperationQueue.mainQueue().addOperationWithBlock { () -> Void in

}复制代码

总结

好的吧，总算写完了，纯手敲6k多字，感动死我了。花了两天，时间跨度有点大，因此可能有些地方上段不接下段或者有的地方不完整，若是你看着比较费力或者有什么地方有问题，均可以在评论区告诉我，我会及时修改的。固然啦，多线程的东西也不止这些，题目也就只是个题目，不要当真。想要了解更多的东西，还得本身去网上挖掘相关资料。多看看官方文档。实在是编不下去了，你们好好看~。对了，看我写的这么卖力，不打赏的话得点个喜欢也是极好的。

做者：伯恩的遗产
连接：https://www.jianshu.com/p/0b0d9b1f1f19

此文章来源于第三方转载

给你们推荐一个iOS技术交流群，群内提供数据结构与算法、底层进阶、swift、逆向、底层面试题整合文档等免费资料！！！

可加我微信邀请你们进群