您看自个儿就够了

在那篇小说中,小编将为您整治一下 iOS
开发中两种二十八线程方案,以及其使用方法和注意事项。当然也会付给二种二十多线程的案例,在实际上利用中感受它们的区分。还有少数急需证实的是,那篇文章将会使用
SwiftObjective-c 二种语言教学,双语幼园。OK,let’s begin!

转发自简书网 笔者
伯恩的遗产 2015.07.29
00:37*http://www.jianshu.com/p/0b0d9b1f1f19

概述

这篇小说中,作者不会说二十四线程是什么样、线程和经过的界别、二十多线程有啥样用,当然笔者也不会说怎么是串行、什么是互相等难题,这么些大家应当都清楚的。

在 iOS 中实际上近日有 4 套二十多线程方案,他们分别是:

  • Pthreads
  • NSThread
  • GCD
  • NSOperation & NSOperationQueue

故此接下去,笔者会一一讲解那些方案的使用方法和有个别案例。在将那一个剧情的时候,笔者也会顺手说一些八线程周边产品。比如:
线程同步延时执行单例格局 等等。

文/Burne的遗产(简书作者)
原稿链接:http://www.jianshu.com/p/0b0d9b1f1f19
文章权归笔者全部,转发请联系笔者获得授权,并标明“简书笔者”。

Pthreads

其实这么些方案不用说的,只是拿来充个数,为了让我们探听一下就好了。百度百Corey是如此说的:

POSIX线程(POSIX
threads),简称Pthreads,是线程的POSIX标准。该专业定义了创立和操纵线程的一整套API。在类Unix操作系统(Unix、Linux、Mac
OS X等)中,都应用Pthreads作为操作系统的线程。

简不难单地说,那是一套在很多操作系统上都通用的二十十二线程API,所以移植性很强(然并卵),当然在
iOS 中也是能够的。可是那是依照 c语言
的框架,使用起来那酸爽!感受一下:

在那篇著作中,作者将为您整治一下 iOS
开发中几种八线程方案,以及其使用方法和注意事项。当然也会付给二种十六线程的案例,在实际应用中感受它们的区分。还有有些亟需证实的是,那篇文章将会利用
SwiftObjective-c 二种语言教学,双语幼园。OK,let’s begin!

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语言函数,那是比较蛋疼的,更蛋疼的是您需求手动处理线程的逐条状态的更换即管理生命周期,比如,那段代码即使创制了一个线程,但并从未灭绝。

概述

那篇文章中,作者不会说多线程是怎么、线程和进度的分别、二十多线程有啥用,当然笔者也不会说怎么是串行、什么是互为等题材,这个我们应有都知晓的。

在 iOS 中实际近期有 4 套八线程方案,他们各自是:

  • Pthreads
  • NSThread
  • GCD
  • NSOperation & NSOperationQueue

为此接下去,笔者会一一讲解那个方案的选择方法和部分案例。在将这么些内容的时候,作者也会顺手说有的十二线程周边产品。比如:
线程同步延时执行单例模式 等等。

SWIFT

很不满,在自笔者当下的 swift1.2
中不只怕推行那套方法,原因是那一个函数必要传入1个函数指针
CFunctionPointer<T> 类型,可是最近 swift 不只怕将艺术转换来此类型。听大人说
swift 2.0 引入三个新特色 @convention(c), 能够成功 Swift 方法转换成 c
语言指针的。在此处能够见到

那么,Pthreads 方案的四线程小编就介绍这么多,终究做 iOS
开发差不离相当的小概用到。可是假如你感兴趣的话,或然说想要自身完成一套二十四线程方案,从最底层开首定制,那么能够去搜一下有关材料。

Pthreads

实则那几个方案不用说的,只是拿来充个数,为了让大家了然一下就好了。百度百Corey是那样说的:

POSIX线程(POSIX
threads),简称Pthreads,是线程的POSIX标准。该专业定义了创建和操纵线程的一整套API。在类Unix操作系统(Unix、Linux、Mac
OS X等)中,都选择Pthreads作为操作系统的线程。

简短地说,这是一套在重重操作系统上都通用的三十二线程API,所以移植性很强(然并卵),当然在
iOS 中也是能够的。然而这是依据 c语言
的框架,使用起来那酸爽!感受一下:

NSThread

那套方案是经过苹果封装后的,并且完周详向对象的。所以你能够平素操控线程对象,十三分直观和有利。不过,它的生命周期照旧必要我们手动管理,所以那套方案也是偶尔用用,比如
[NSThread currentThread],它能够拿走当前线程类,你就足以精晓当前线程的种种质量,用于调节和测试12分便于。上面来看望它的有的用法。

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语言函数,那是相比较蛋疼的,更蛋疼的是你需求手动处理线程的相继状态的转移即管理生命周期,比如,这段代码尽管创制了三个线程,但并不曾灭绝。

创立并运维

  • 先创设线程类,再开发银行

    ###### 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.

SWIFT

很不满,在自身最近的 swift1.2
中不可能履行那套方法,原因是其一函数须要传入3个函数指针
CFunctionPointer<T> 类型,不过当前 swift 不恐怕将艺术转换来此类型。听大人讲
swift 2.0 引入二个新特征 @convention(c), 能够形成 斯维夫特 方法转换来 c
语言指针的。在那里能够看看

那么,Pthreads 方案的三十二线程小编就介绍这么多,毕竟做 iOS
开发大约不容许用到。不过假诺您感兴趣的话,可能说想要本人实现一套十六线程方案,从底部早先定制,那么能够去搜一下连锁资料。

别的艺术

除却成立运营外,NSThread
还以很多艺术,上边笔者列举部分科学普及的法子,当然小编列举的并不完整,越多格局大家能够去类的概念里去看。

NSThread

那套方案是通过苹果封装后的,并且完周全向对象的。所以你可以间接操控线程对象,卓殊直观和方便。但是,它的生命周期照旧须求大家手动管理,所以那套方案也是突发性用用,比如
[NSThread currentThread],它能够获取当前线程类,你就能够领略当前线程的各个质量,用于调节和测试10分福利。上面来探望它的部分用法。

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;

创制并运转

  • 先成立线程类,再开发银行

    ###### 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: 不安全,所以在 斯维夫特去掉了这几个措施。

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

SWIFT

斯威夫特的办法名字和OC的点子名都一样,笔者就不浪费空间列举出来了。

事实上,NSThread
用起来也挺简单的,因为它就那三种办法。同时,大家也唯有在有个别格外不难的光景才会用
NSThread,
毕竟它还不够智能,无法优雅地处理八线程中的其余高级概念。所以接下去要说的始末才是必不可缺。

其余情势

而外创制运行外,NSThread
还以很多方法,下边小编列举部分广大的办法,当然笔者列举的并不完全,越来越多形式我们可以去类的定义里去看。

GCD

Grand Central Dispatch,听名字就霸道。它是苹果为多核的互相运算建议的解决方案,所以会活动合理地应用更加多的CPU内核(比如双核、四核),最要害的是它会自动管理线程的生命周期(创设线程、调度职务、销毁线程),完全不要求我们管理,大家只要求告诉干什么就行。同时它使用的也是
c语言,可是是因为采纳了
Block(Swift里叫做闭包),使得应用起来更为便于,而且灵活。所以基本上海大学家都利用
GCD
那套方案,老少咸宜,实在是住家旅行、不留余地,必备良药。倒霉意思,有点中二,咱们继续。

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;

职务和队列

GCD 中,参预了四个要命首要的概念: 任务队列

  • 职责:即操作,你想要干什么,说白了就是一段代码,在 GCD 中就是一个Block,所以添加义务尤其便利。职责有三种实施措施: 同台执行
    异步执行,他们中间的区分是 是否会创建新的线程

    一道实施只要是同步执行的任务,都会在当前线程执行,不会另开线程。

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

    更新
    那边说的并不规范,同步(sync)异步(async)
    的重点分裂在于会不会阻塞当前线程,直到 Block
    中的职务履行达成!
    如果是 同步(sync) 操作,它会阻塞当前线程并听候 Block
    中的职责履行完结,然后当前线程才会持续往下运作。
    如果是
    异步(async)操作,当前线程会直接往下实施,它不会卡住当前线程。

  • 队列:用于存放职务。一共有二种队列, 串行队列交互队列

    串行队列 中的任务会依照队列的概念 FIFO
    的实行,二个接贰个的先进先出的展开实施。

更新:放到串行队列的职分,GCD 会 FIFO(先进先出)
地取出来叁个,执行1个,然后取下二个,那样2个一个的履行。

相互队列 中的职务 根据同步或异步有不同的执行方式。

更新:放到并行队列的天职,GCD 也会
FIFO的取出来,但差别的是,它取出来多个就会停放别的线程,然后再取出来一个又放手另一个的线程。那样由于取的动作火速,忽略不计,看起来,全数的职责都以一路实施的。不过供给留意,GCD
会依据系统能源控制并行的数量,所以一旦职分过多,它并不会让具有职责同时推行。

固然很绕,但请看下表:

同步执行 异步执行
串行队列 当前线程,一个一个执行 其他线程,一个一个执行
并行队列 当前线程,一个一个执行 开很多线程,一起执行
SWIFT

Swift的方法名字和OC的法子名都一样,笔者就不浪费空间列举出来了。

实际,NSThread
用起来也挺不难的,因为它就那三种办法。同时,大家也唯有在局地卓殊不难的现象才会用
NSThread,
毕竟它还不够智能,不能够优雅地处理三十二线程中的别的高档概念。所以接下去要说的内容才是生死攸关。

创设队列

  • 主队列:那是3个破例的
    串行队列。什么是主队列,我们都晓得吧,它用于刷新 UI,任何索要刷新
    UI 的干活都要在主队列执行,所以一般耗费时间的职分都要放到别的线程执行。

      //OBJECTIVE-C
      dispatch_queue_t queue = ispatch_get_main_queue();
    
      //SWIFT
      let queue = ispatch_get_main_queue()
    
  • 协调创设的队列凡是自己创建的队列都是 `串行队列`。
    在这之中第多个参数是标识符,用于 DEBUG
    的时候标识唯一的体系,能够为空。大家可以看xcode的文书档案查看参数意义。

更新:本人能够创设 串行队列, 也足以创建
并行队列。看上边包车型大巴代码(代码已更新),它有五个参数,第3个地点已经说了,首个才是最主要的。
其次个参数用来代表创立的行列是串行的或然并行的,传入
DISPATCH_QUEUE_SERIALNULL 表示成立串行队列。传入
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)
    

GCD

Grand Central Dispatch,听名字就霸道。它是苹果为多核的交互运算建议的缓解方案,所以会自动合理地动用越来越多的CPU内核(比如双核、四核),最注重的是它会自行政管理理线程的生命周期(成立线程、调度任务、销毁线程),完全不必要我们管理,大家只需求告诉干什么就行。同时它选取的也是
c语言,不过由于使用了
Block(斯维夫特里叫做闭包),使得应用起来更为有益于,而且灵活。所以基本上海大学家都使用
GCD
那套方案,老少咸宜,实在是住户旅行、赶尽杀绝,必备良药。不好意思,有点中二,我们继续。

创办职责

  • 同台任务: 不会另开线程 改:会阻塞当前线程 (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]);
});

职责和队列

GCD 中,参加了八个10分重庆大学的定义: 任务队列

  • 职分:即操作,你想要干什么,说白了就是一段代码,在 GCD 中便是四个Block,所以添加职分格外方便人民群众。职分有三种实施格局: 一同实施
    异步执行,他们之间的界别是 是否会创建新的线程

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

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

    更新
    此处说的并不标准,同步(sync)异步(async)
    的基本点差异在于会不会堵塞当前线程,直到 Block
    中的职责履行完结!
    如果是 同步(sync) 操作,它会阻塞当前线程并等待 Block
    中的义务执行完结,然后当前线程才会继续往下运作。
    如果是
    异步(async)操作,当前线程会向来往下实施,它不会卡住当前线程。

  • 队列:用于存放职责。一共有二种队列, 串行队列相互队列

    串行队列 中的任务会依照队列的概念 FIFO
    的履行,3个接三个的先进先出的展开实施。

    更新:放到串行队列的天职,GCD 会 FIFO(先进先出)
    地取出来多个,执行2个,然后取下贰个,这样一个二个的履行。

    互动队列 中的职务 根据同步或异步有不同的执行方式。

    更新:放到并行队列的职责,GCD 也会
    FIFO的取出来,但不一致的是,它取出来二个就会安置其他线程,然后再取出来八个又放到另贰个的线程。那样由于取的动作迅捷,忽略不计,看起来,所有的任务都以联合实施的。但是要求专注,GCD
    会依照系统财富控制并行的多寡,所以假使职务过多,它并不会让具备职务同时执行。

虽说很绕,但请看下表:

  同步执行 异步执行
串行队列 当前线程,一个一个执行 其他线程,一个一个执行
并行队列 当前线程,一个一个执行 开很多线程,一起执行
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 一样了。

始建队列

  • 主队列:那是叁个新鲜的
    串行队列。什么是主队列,我们都通晓呢,它用来刷新 UI,任何必要刷新
    UI 的工作都要在主队列执行,所以一般耗费时间的天职都要放置其余线程执行。

      //OBJECTIVE-C
      dispatch_queue_t queue = ispatch_get_main_queue();
    
      //SWIFT
      let queue = ispatch_get_main_queue()
    
  • 温馨创设的体系凡是自己创建的队列都是 `串行队列`。
    当中第③个参数是标识符,用于 DEBUG
    的时候标识唯一的连串,能够为空。大家可以看xcode的文书档案查看参数意义。

    更新:本人能够成立 串行队列, 也能够创设
    并行队列。看下面包车型客车代码(代码已更新),它有三个参数,第贰个地方已经说了,第一个才是最要害的。
    其次个参数用来代表成立的行列是串行的或许并行的,传入
    DISPATCH_QUEUE_SERIALNULL 表示成立串行队列。传入
    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)
    

NSOperation和NSOperationQueue

NSOperation 是苹果公司对 GCD
的包装,完周到向对象,所以采用起来更好领悟。 大家可以见见
NSOperation 和 NSOperationQueue 分别对应 GCD 的 任务 和 队列
。操作步骤也很好掌握:

  1. 就要执行的天职封装到二个 NSOperation 对象中。
  2. 将此职责添加到二个 NSOperationQueue 对象中。

下一场系统就会自动在进行职务。至于同步照旧异步、串行照旧并行请继续往下看:

开创职责

  • 手拉手职分: 不会另开线程 改:会堵塞当前线程 (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())

答案:
只会打字与印刷第3句:之前 - <NSThread: 0x7fb3a9e16470>{number = 1, name = main}
,然后主线程就卡死了,你可以在界面上放一个按钮,你就会发现点持续了。
解释:
一齐任务会堵塞当前线程,然后把 Block
中的职责放到钦定的行列中实践,只有等到 Block
中的职责成功后才会让日前线程继续往下运营。
那就是说那里的手续正是:打印完第1句后,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 这一个参数,创建了1个 串行队列
  2. 打印出 之前 - %@ 这句。
  3. dispatch_async
    异步执行,所以当前线程不会被卡住,于是有了两条线程,一条当前线程继续往下打字与印刷出
    之后 - %@那句, 另一台执行 Block 中的内容打字与印刷 sync之前 - %@
    那句。因为那两条是相互的,所以打字与印刷的先后顺序无所谓。
  4. 在意,高潮来了。以往的图景和上二个例子一样了。dispatch_sync联机施行,于是它所在的线程会被卡住,一贯等到
    sync 里的职责履行完才会一连往下。于是 sync 就欣喜的把温馨
    Block 中的职责放到 queue 中,可谁想 queue
    是三个串行队列,1次实施二个职分,所以 sync 的 Block
    必须等到前二个职分履行实现,可相对没悟出的是 queue
    正在执行的任务便是被 sync 阻塞了的老大。于是又发出了死锁。所以
    sync 所在的线程被卡死了。剩下的两句代码自然不会打字与印刷。

添加任务

值得表明的是,NSOperation 只是1个抽象类,所以不能够封装职责。但它有 2个子类用于封装职分。分别是:NSInvocationOperation
NSBlockOperation 。成立3个 Operation 后,供给调用 start
方法来运维职分,它会
暗中认可在脚下队列同步施行。当然你也能够在半路打消多个职务,只须求调用其
cancel 方法即可。

  • NSInvocationOperation : 要求传入1个措施名。

    ###### OBJECTIVE-C

      //1.创建NSInvocationOperation对象
      NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];
    
      //2.开始执行
      [operation start];
    

    ###### 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
    还有1个措施: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}

    NOTEaddExecutionBlock 方法必须在 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()
    在内的种种艺术。所以这么些职能提须要高档玩家,作者在那边就隐瞒了,等自己必要用到时在商量它,到时候恐怕会再做立异。

队列组

队列组能够将洋洋行列添加到一个组里,那样做的裨益是,当以此组里全体的天职都履行完了,队列组会通过三个主意文告大家。上边是行使方法,这是1个很实用的效益。

创设队列

看过地点的内容就明白,我们能够调用四个 NSOperation 对象的 start()
方法来运行这几个义务,可是这么做他们默许是 一起施行 的。就算是
addExecutionBlock 方法,也会在 现阶段线程和其余线程
中履行,也等于说依然会占有当前线程。这是即将用到行列 NSOperationQueue
了。而且,按类型来说的话一共有二种档次:主队列、别的队列。假诺添加到行列,会自动调用任务的
start() 方法

  • 主队列

    周密的同桌就会意识,每套三十二线程方案都会有八个主线程(当然啦,说的是iOS中,像
    pthread 那种多系统的方案并没有,因为 UI线程
    理论要求各种操作系统本身定制)。那是贰个新鲜的线程,必须串行。所以添加到主队列的任务都会1个接二个地排着队在主线程处理。

    //OBJECTIVE-C
    NSOperationQueue *queue = [NSOperationQueue mainQueue];
    
    //SWIFT
    let queue = NSOperationQueue.mainQueue()
    

  • 其它队列

    因为主队列比较特出,所以会单独有3个类措施来收获主队列。那么通过起始化发生的队列便是任何队列了,因为只有那二种队列,除了主队列,其余队列就不要求名字了。

    瞩目:别的队列的任务会在任何线程并行执行。

    ###### 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, 那时应该咨询了,大家将 NSOperationQueueGCD的队列
相比较就会发现,那里没有串行队列,那假如笔者想要13个任务在别的线程串行的进行如何是好?

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

NSOperationQueue
还有三个增进职务的方法,- (void)addOperationWithBlock:(void (^)(void))block;
,那是或不是和 GCD 大致?那样就能够增进2个职责到行列中了,十二分便于。

NSOperation 有三个10分实用的效用,那正是添加信赖。比如有 3 个义务:A:
从服务器上下载一张图纸,B:给那张图纸加个水印,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]);
});
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 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):
    本条格局的使用和上1个如出一辙,传入
    自定义的出现队列(DISPATCH_QUEUE_CONCURRENT),它和上八个形式同样的堵塞
    queue,差别的是 那几个法子还会 堵塞当前线程
    比方你传入的是此外的 queue, 那么它就和 dispatch_sync
    一样了。

NSOperation和NSOperationQueue

NSOperation 是苹果集团对 GCD
的包裹,完全面向对象,所以采纳起来更好精通。 我们能够看出
NSOperation 和 NSOperationQueue 分别对应 GCD 的 任务 和 队列
。操作步骤也很好掌握:

  1. 就要执行的职责封装到2个 NSOperation 对象中。
  2. 将此义务添加到一个 NSOperationQueue 对象中。

接下来系统就会活动在履行义务。至于同步依旧异步、串行照旧并行请继续往下看:

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)

增加职分

值得表达的是,NSOperation 只是四个抽象类,所以无法封装职责。但它有 三个子类用于封装职分。分别是: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}

    NOTEaddExecutionBlock 方法必须在 start()
    方法在此之前实施,不然就会报错:

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

    NOTE:我们莫不发现了贰个难点,为何自身在 斯维夫特 里打字与印刷输出使用
    NSLog() 而不是 println() 呢?原因是行使 print() / println()
    输出的话,它会简单地选拔 流(stream) 的概念,学过 C++
    的都精晓。它会把须要输出的各种字符一个多少个的出口到控制台。普通应用并没不平常,不过当八线程同步输出的时候难题就来了,由于众多
    println()
    同时打字与印刷,就会招致控制台上的字符混乱的堆在共同,而NSLog()
    就从不这么些题材。到底是如何体统的啊?你能够把上边 NSLog() 改为
    println() ,然后一试便知。 越多 NSLog() 与 println()
    的界别看那里

  • 自定义Operation

    除却下面的三种 Operation 以外,我们还能自定义 Operation。自定义
    Operation 供给继承 NSOperation 类,并贯彻其 main()
    方法,因为在调用 start() 方法的时候,内部会调用 main()
    方法成功有关逻辑。所以如若上述的多个类无法满意你的私欲的时候,你就须要自定义了。你想要完成怎么着效益都得以写在在那之中。除此之外,你还亟需贯彻
    cancel()
    在内的各样艺术。所以这一个效能提须求高档玩家,小编在此处就隐瞒了,等作者要求用到时在研讨它,到时候大概会再做革新。

打字与印刷结果

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 对象的 start()
方法来运转那几个职务,可是如此做他们暗中认可是 联机施行 的。就算是
addExecutionBlock 方法,也会在 当前线程和任何线程
中施行,也等于说依旧会占用当前线程。那是快要用到行列 NSOperationQueue
了。而且,按类型来说的话一共有两体系型:主队列、别的队列。借使添加到行列,会活动调用职责的
start() 方法

  • 主队列

    周全的同班就会意识,每套二十十二线程方案都会有3个主线程(当然啦,说的是iOS中,像
    pthread 那种多系统的方案并不曾,因为 UI线程
    理论需求各样操作系统自个儿定制)。这是3个异样的线程,必须串行。所以添加到主队列的职务都会一个接3个地排着队在主线程处理。

    //OBJECTIVE-C
    NSOperationQueue *queue = [NSOperationQueue mainQueue];
    
    //SWIFT
    let queue = NSOperationQueue.mainQueue()
    

  • 别的队列

    因为主队列相比优良,所以会独自有3个类情势来博取主队列。那么通过初叶化产生的系列就是其他队列了,因为只有那二种队列,除了主队列,别的队列就不必要名字了。

    留意:别的队列的任务会在其余线程并行执行。

    ###### 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, 那时应该咨询了,大家将 NSOperationQueueGCD的队列
绝相比较就会发觉,那里没有串行队列,那若是本人想要拾一个义务在别的线程串行的举办如何是好?

那就是苹果封装的妙处,你不用管串行、并行、同步、异步这几个名词。NSOperationQueue
有二个参数 maxConcurrentOperationCount
最大并发数,用来安装最多能够让多少个职务同时执行。当你把它设置为 1
的时候,他不正是串行了嘛!

NSOperationQueue
还有一个抬高职务的格局,- (void)addOperationWithBlock:(void (^)(void))block;
,那是或不是和 GCD 大概?那样就足以加上3个职分到行列中了,十三分有益于。

NSOperation 有1个要命实用的功效,那便是丰裕重视。比如有 3 个职务:A:
从服务器上下载一张图纸,B:给那张图纸加个水印,C:把图片再次来到给服务器。那时就足以用到依靠了:

任何方法

如上正是一对主要措施, 上面还有一对常用方法需求我们只顾:

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

线程同步

所谓线程同步正是为着防止八个线程抢夺同二个资源造成的数码安全题材,所使用的一种办法。当然也有那些兑现格局,请往下看:

  • 互斥锁
    :给须要联合的代码块加二个互斥锁,就足以确定保证每一次只有2个线程访问此代码块。

    ###### OBJECTIVE-C

    @synchronized(self) {
      //需要执行的代码块
    }
    

    ###### SWIFT

    objc_sync_enter(self)
    //需要执行的代码块
    objc_sync_exit(self)
    
  • 手拉手实施
    :我们可以选拔二十三十二线程的文化,把三个线程都要实施此段代码添加到同三个串行队列,那样就兑现了线程同步的定义。当然那里能够动用
    GCDNSOperation 两种方案,小编都写出来。

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

//后续要做的事
打字与印刷结果

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 来解除依赖关系。
  • 能够在不相同的类别之间注重,反正正是这些依靠是加上到职务身上的,和队列没关系。
SWIFT

那边的 swift 代码,小编就不写了,因为每句都同一,只是语法分裂而已,照着 OC
的代码就能写出 斯威夫特的。那篇文章已经老长老长了,笔者就不浪费篇幅了,又不是高中写作文。

任何情势

如上便是有的关键形式, 下边还有一对常用方法供给大家瞩目:

  • 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

好啊,到那里基本上就讲完了。当然,笔者讲的并不完全,或许有一部分文化作者并从未讲到,但作为常用方法,这一个已经丰硕了。可是自身在那里只是告诉你了某个格局的效果,只是怎么把他们用到适合的地点,就必要多多实践了。上边小编会说一些关于四线程的案例,是大家越发什么地询问。

延迟执行

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

  • 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

    @synchronized(self) {
        //需要执行的代码块
    }
    

    ###### SWIFT

    objc_sync_enter(self)
    //需要执行的代码块
    objc_sync_exit(self)
    
  • 一块执行
    :大家得以行使多线程的学识,把几个线程都要实施此段代码添加到同3个串行队列,那样就落到实处了线程同步的定义。当然那里能够应用
    GCDNSOperation 二种方案,笔者都写出来。

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

  //后续要做的事
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
方法。下边看 斯威夫特 中的单例情势,在斯维夫特中单例形式格外简单!想清楚怎么从
OC
那么复杂的法子成为上面包车型大巴写法的,请看这里

SWIFT

那边的 swift 代码,小编就不写了,因为每句都同一,只是语法差异而已,照着 OC
的代码就能写出 Swift的。那篇文章已经老长老长了,作者就不浪费篇幅了,又不是高级中学写作文。

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

    // 私有化构造方法,阻止其他对象使用这个类的默认的'()'构造方法
    private override init() {}
}

延期执行

所谓延迟执行正是延时一段时间再实践某段代码。上边说一些常用方法。

  • perform

    ###### OBJECTIVE-C

      // 3秒后自动调用self的run:方法,并且传递参数:@"abc"
      [self performSelector:@selector(run:) withObject:@"abc" afterDelay:3];
    

    ###### SWIFT

    之前就已经说过,Swift 里去掉了这个方法。
    
  • GCD

    能够采纳 GCD 中的 dispatch_after 方法,OC 和 斯威夫特都足以动用,那里只写 OC 的,斯维夫特 的是一样的。

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

从此外线程回到主线程的主意

我们都知道在其它线程操作达成后必须到主线程更新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
    
    }
    

单例情势

关于何以是单例方式,笔者也不多说,小编只说说一般怎么落到实处。在 Objective-C
中,达成单例的艺术已经很实际了,虽然有其余艺术,不过一般都以用叁个标准的格局了,上边来探望。

总结

好的吗,总算写完了,纯手敲6k多字,感动死作者了。花了两日,时间跨度有点大,所以大概某些地点上段不接下段大概局部地点不完整,假诺您瞧着相比棘手或许有怎么着地点有标题,都得以在评论区告诉本身,作者会立马特hew改的。当然啦,三十二线程的事物也不断那几个,题目也就只是个难点,不要当真。想要通晓越来越多的事物,还得投机去网上挖掘城门失火材质。多看看官方文书档案。实在是编不下去了,大家好赏心悦目~。对了,看本人写的这么努力,不打赏的话得点个喜欢也是极好的。

更新:第二次放出去的时候,有好多地点有荒唐,很感激有心上人提出来了。假诺您看到有不当的地点,一定记得提议来,这样对我们都有援助。还有少数对初学者的话,碰到不懂的艺术,最好的艺术正是翻开官方文书档案,那里是最纯粹的,就算有多少个单词不认得,查一下就好了,不会影响对全体的明白。
小编看齐有网站转发了作者的稿子,但转发的或是存在难题,而自身只得在简书上革新,所以就算要看
一体化版本
照旧到简书来看吗:此地是地方

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 中的单例形式,在斯威夫特中单例形式万分简单!想精晓怎么从
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多字,感动死作者了。花了两日,时间跨度有点大,所以或许有点地点上段不接下段大概某些地点不完全,假诺您望着相比较困难大概有何地点有标题,都得以在评论区告诉小编,笔者会立即修改的。当然啦,多线程的东西也频频那些,题目也就只是个难题,不要当真。想要明白越多的东西,还得要好去网上挖掘休戚相关资料。多看看官方文书档案。实在是编不下来了,大家好美观~。对了,看本身写的这么努力,不打赏的话得点个爱好也是极好的。

更新:第二次放出去的时候,有众多地点有不当,很感激有心上人建议来了。要是你看来有错误的地点,一定记得提议来,那样对大家都有帮扶。还有有个别对初学者的话,碰着不懂的艺术,最好的不二法门就是查看官方文档,那里是最规范的,固然有多少个单词不认识,查一下就好了,不会潜移默化对全部的了然。
自小编看看有网站转发了自家的稿子,但转发的或然存在难点,而本身只能在简书上立异,所以一旦要看
总体版本
照旧到简书来看呢:此地是地点

相关文章