IOS 多线程知识学习

作者: John_LS | 来源:发表于2016-05-18 15:31 被阅读209次

学习多线程，转载两篇大神的帖子，留着以后回顾！
第一篇：关于iOS多线程，你看我就够了
第二篇：GCD使用经验与技巧浅谈
都很不错，还有很多关联文章，慢慢学！！！多看原帖！！！
第三篇：IOS GCD开发学习中

在这篇文章中，整理一下 iOS 开发中几种多线程方案，以及其使用方法和注意事项。当然也会给出几种多线程的案例，在实际使用中感受它们的区别。还有一点需要说明的是，这篇文章将会使用 Swift 和 Objective-c 两种语言讲解!

概述

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

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

Pthreads

NSThread
GCD (Grand Central Dispatch )
NSOperation & NSOperationQueue

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

Pthreads

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

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

简单地说，这是一套在很多操作系统上都通用的多线程API，所以移植性很强（然并卵），当然在 iOS 中也是可以的。不过这是基于 c语言的框架，使用起来这酸爽！感受一下：


define NSEC_PER_SEC 1000000000ull
define USEC_PER_SEC 1000000ull
define NSEC_PER_USEC 1000ull

关键词解释：

NSEC：纳秒。
USEC：微妙。
SEC：秒
PER：每
所以：
NSEC_PER_SEC，每秒有多少纳秒。
USEC_PER_SEC，每秒有多少毫秒。（注意是指在纳秒的基础上）
NSEC_PER_USEC，每毫秒有多少纳秒。
所以，延时1秒可以写成如下几种：

dispatch_time(DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC); 
dispatch_time(DISPATCH_TIME_NOW, 1000 * USEC_PER_SEC); 
dispatch_time(DISPATCH_TIME_NOW, USEC_PER_SEC * NSEC_PER_USEC);

最后一个“USEC_PER_SEC * NSEC_PER_USEC”，翻译过来就是“每秒的毫秒数乘以每毫秒的纳秒数”，也就是“每秒的纳秒数”，所以，延时500毫秒之类的，也就不难了吧~

OBJECTIVE-C

当然第一步要包含头文件

#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;
}

打印输出：

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 中就是一个 Block，所以添加任务十分方便。任务有两种执行方式： 同步执行 和 异步执行，他们之间的区别是:会不会阻塞当前线程，直到** Block** 中的任务执行完毕！
。
同步执行：会阻塞当前线程并等待 Block 中的任务执行完毕，然后当前线程才会继续往下运行。
异步执行：当前线程会直接往下执行，它不会阻塞当前线程.
队列：用于存放任务。一共有两种队列，串行队列和并行队列。

串行队列 中的任务会根据队列的定义 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 的时候标识唯一的队列，可以为空。第二个参数用来表示创建的队列是串行的还是并行的，传入 DISPATCH_QUEUE_SERIAL 或 NULL 表示创建串行队列。传入 DISPATCH_QUEUE_CONCURRENT 表示创建并行队列。大家可以看xcode的文档查看参数意义。

//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之后- %@没有被打印出来！这是为什么呢？我们再来分析一下：
分析：我们按执行顺序一步步来哦：

使用DISPATCH_QUEUE_SERIAL这个参数，创建了一个 串行队列。
打印出之前 - %@这句。
dispatch_async异步执行，所以当前线程不会被阻塞，于是有了两条线程，一条当前线程继续往下打印出之后 - %@
这句, 另一台执行 Block 中的内容打印sync之前- %@这句。因为这两条是并行的，所以打印的先后顺序无所谓。
注意，高潮来了。现在的情况和上一个例子一样了。dispatch_sync同步执行，于是它所在的线程会被阻塞，一直等到sync里的任务执行完才会继续往下。于是sync就高兴的把自己 Block 中的任务放到queue
中，可谁想queue是一个串行队列，一次执行一个任务，所以sync的 Block 必须等到前一个任务执行完毕，可万万没想到的是queue正在执行的任务就是被sync阻塞了的那个。于是又发生了死锁。所以sync所在的线程被卡死了。剩下的两句代码自然不会打印。

队列组

队列组可以将很多队列添加到一个组里，这样做的好处是，当这个组里所有的任务都执行完了，队列组会通过一个方法通知我们。下面是使用方法，这是一个很实用的功能

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一样了。

关于更详细的GCD基础补充

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 方法。

//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

}

其他

dispatch_suspend != 立即停止队列的运行

dispatch_suspend，dispatch_resume提供了“挂起、恢复”队列的功能，简单来说，就是可以暂停、恢复队列上的任务。但是这里的“挂起”，并不能保证可以立即停止队列上正在运行的block，看如下例子：

dispatch_queue_t queue = dispatch_queue_create(“me.tutuge.test.gcd”, DISPATCH_QUEUE_SERIAL);

//提交第一个block，延时5秒打印。 
dispatch_async(queue, ^{ 
[NSThread sleepForTimeInterval:5]; 
NSLog(@”After 5 seconds…”); 
});

//提交第二个block，也是延时5秒打印 
dispatch_async(queue, ^{ 
[NSThread sleepForTimeInterval:5]; 
NSLog(@”After 5 seconds again…”); 
});

//延时一秒 
NSLog(@”sleep 1 second…”); 
[NSThread sleepForTimeInterval:1];

//挂起队列 
NSLog(@”suspend…”); 
dispatch_suspend(queue);

//延时10秒 
NSLog(@”sleep 10 second…”); 
[NSThread sleepForTimeInterval:10];

//恢复队列 
NSLog(@”resume…”); 
dispatch_resume(queue);

运行结果如下：

2015-04-01 00:32:09.903 GCDTest[47201:1883834] sleep 1 second… 
2015-04-01 00:32:10.910 GCDTest[47201:1883834] suspend… 
2015-04-01 00:32:10.910 GCDTest[47201:1883834] sleep 10 second… 
2015-04-01 00:32:14.908 GCDTest[47201:1883856] After 5 seconds… 
2015-04-01 00:32:20.911 GCDTest[47201:1883834] resume… 
2015-04-01 00:32:25.912 GCDTest[47201:1883856] After 5 seconds again…

可知，在dispatch_suspend挂起队列后，第一个block还是在运行，并且正常输出。
结合文档，我们可以得知，dispatch_suspend并不会立即暂停正在运行的block，而是在当前block执行完成后，暂停后续的block执行。

所以下次想暂停正在队列上运行的block时，还是不要用dispatch_suspend了吧~

“同步”的dispatch_apply

dispatch_apply的作用是在一个队列（串行或并行）上“运行”多次block，其实就是简化了用循环去向队列依次添加block任务。但是我个人觉得这个函数就是个“坑”，先看看如下代码运行结果：

//创建异步串行队列 
dispatch_queue_t queue = dispatch_queue_create(“me.tutuge.test.gcd”, DISPATCH_QUEUE_SERIAL);

//运行block3次 
dispatch_apply(3, queue, ^(size_t i) { 
NSLog(@”apply loop: %zu”, i); 
});

//打印信息 
NSLog(@”After apply”);

运行的结果是：

2015-04-01 00:55:40.854 GCDTest[47402:1893289] apply loop: 0 
2015-04-01 00:55:40.856 GCDTest[47402:1893289] apply loop: 1 
2015-04-01 00:55:40.856 GCDTest[47402:1893289] apply loop: 2 
2015-04-01 00:55:40.856 GCDTest[47402:1893289] After apply

看，明明是提交到异步的队列去运行，但是“After apply”居然在apply后打印，也就是说，dispatch_apply将外面的线程（main线程）“阻塞”了！

查看官方文档，dispatch_apply确实会“等待”其所有的循环运行完毕才往下执行=。=，看来要小心使用了。

避免死锁！

dispatch_sync导致的死锁

涉及到多线程的时候，不可避免的就会有“死锁”这个问题，在使用GCD时，往往一不小心，就可能造成死锁，看看下面的“死锁”例子：

//在main线程使用“同步”方法提交Block，必定会死锁。 
dispatch_sync(dispatch_get_main_queue(), ^{ 
NSLog(@”I am block…”); 
});

你可能会说，这么低级的错误，我怎么会犯，那么，看看下面的：

(void)updateUI1 { 
dispatch_sync(dispatch_get_main_queue(), ^{ 
NSLog(@”Update ui 1”);

//死锁！
[self updateUI2];
}); 
}

(void)updateUI2 { 
dispatch_sync(dispatch_get_main_queue(), ^{ 
NSLog(@”Update ui 2”); 
}); 
}

在你不注意的时候，嵌套调用可能就会造成死锁！所以为了“世界和平”=。=，我们还是少用dispatch_sync吧。

dispatch_apply导致的死锁！

dispatch_apply导致的死锁？。。。是的，前一节讲到，dispatch_apply会等循环执行完成，这不就差不多是阻塞了吗。看如下例子：

dispatch_queue_t queue = dispatch_queue_create(“me.tutuge.test.gcd”, DISPATCH_QUEUE_SERIAL);

dispatch_apply(3, queue, ^(size_t i) { 
NSLog(@”apply loop: %zu”, i);

//再来一个dispatch_apply！死锁！      
dispatch_apply(3, queue, ^(size_t j) {
    NSLog(@"apply loop inside %zu", j);
});
});

这段代码只会输出“apply loop: 1”。。。就没有然后了=。=

所以，一定要避免dispatch_apply的嵌套调用。

灵活使用dispatch_group

很多时候我们需要等待一系列任务（block）执行完成，然后再做一些收尾的工作。如果是有序的任务，可以分步骤完成的，直接使用串行队列就行。但是如果是一系列并行执行的任务呢？这个时候，就需要dispatch_group帮忙了~总的来说，dispatch_group的使用分如下几步：

创建dispatch_group_t

添加任务（block）
添加结束任务（如清理操作、通知UI等）

下面着重讲讲在后面两步。

1. 添加任务

添加任务可以分为以下两种情况：
(1)自己创建队列：使用dispatch_group_async。
(2)无法直接使用队列变量（如使用AFNetworking添加异步任务）：使用dispatch_group_enter，dispatch_group_leave。
自己创建队列时，当然就用dispatch_group_async函数，简单有效，简单例子如下：

//省去创建group、queue代码。。。

dispatch_group_async(group, queue, ^{ 
//Do you work… 
}); 
当你无法直接使用队列变量时，就无法使用dispatch_group_async了，下面以使用AFNetworking时的情况：

AFHTTPRequestOperationManager *manager = [AFHTTPRequestOperationManager manager];

//Enter group 
dispatch_group_enter(group); 
[manager GET:@”http://www.baidu.com” parameters:nil success:^(AFHTTPRequestOperation *operation, id responseObject) { 
//Deal with result…

//Leave group
dispatch_group_leave(group);
} failure:^(AFHTTPRequestOperation *operation, NSError *error) { 
//Deal with error…

//Leave group
dispatch_group_leave(group);
}];
//More request…

使用dispatch_group_enter，dispatch_group_leave就可以方便的将一系列网络请求“打包”起来~

2. 添加结束任务

添加结束任务也可以分为两种情况，如下：

(1)在当前线程阻塞的同步等待：dispatch_group_wait。
(2)添加一个异步执行的任务作为结束任务：dispatch_group_notify

这两个比较简单，就不再贴代码了=。=

使用dispatch_barrier_async,dispatch_barrier_sync的注意事项

dispatch_barrier_async的作用就是向某个队列插入一个block，当目前正在执行的block运行完成后，阻塞这个block后面添加的block，只运行这个block直到完成，然后再继续后续的任务，有点“唯我独尊”的感觉=。=
值得注意的是：
dispatchbarrier(a)sync只在自己创建的并发队列上有效，在全局(Global)并发队列、串行队列上，效果跟dispatch_(a)sync效果一样。
既然在串行队列上跟dispatch_(a)sync效果一样，那就要小心别死锁！
dispatch_set_context与dispatch_set_finalizer_f的配合使用
dispatch_set_context可以为队列添加上下文数据，但是因为GCD是C语言接口形式的，所以其context参数类型是“void *”。也就是说，我们创建context时有如下几种选择：

用C语言的malloc创建context数据。

用C++的new创建类对象。
用Objective-C的对象，但是要用__bridge等关键字转为Core Foundation对象。

以上所有创建context的方法都有一个必须的要求，就是都要释放内存！，无论是用free、delete还是CF的CFRelease，我们都要确保在队列不用的时候，释放context的内存，否则就会造成内存泄露。

所以，使用dispatch_set_context的时候，最好结合dispatch_set_finalizer_f使用，为队列设置“析构函数”，在这个函数里面释放内存，大致如下：

void cleanStaff(void *context) { 
//释放context的内存！

//CFRelease(context);
//free(context);
//delete context;
}

参考

Grand Central Dispatch (GCD) Reference
Concurrency Programming Guide
Using Dispatch Groups to Wait for Multiple Web Services

IOS 多线程知识学习

概述

Pthreads

关键词解释：

OBJECTIVE-C

SWIFT

NSThread

创建并启动

OBJECTIVE-C

SWIFT

OBJECTIVE-C

SWIFT

OBJECTIVE-C

SWIFT

其他方法

OBJECTIVE-C

SWIFT

GCD

任务和队列

创建队列

创建任务

OBJECTIVE-C

SWIFT

OBJECTIVE-C

SWIFT

队列组

OBJECTIVE-C

SWIFT

NSOperation和NSOperationQueue

添加任务

OBJECTIVE-C

SWIFT

OBJECTIVE-C

SWIFT

OBJECTIVE-C

SWIFT

创建队列

OBJECTIVE-C

SWIFT

OBJECTIVE-C

SWIFT

其他方法

其他用法

线程同步

SWIFT

OBJECTIVE-C

SWIFT

延迟执行

OBJECTIVE-C

SWIFT

OBJECTIVE-C

OBJECTIVE-C

单例模式

OBJECTIVE-C

SWIFT

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

其他

“同步”的dispatch_apply

dispatch_sync导致的死锁

dispatch_apply导致的死锁！

灵活使用dispatch_group

1. 添加任务

2. 添加结束任务

使用dispatch_barrier_async,dispatch_barrier_sync的注意事项

参考

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

ios专题