爱博体育有关iOS多线程,你看我哪怕够用了。关于iOS多线程,你看自己就足够了。

以即时篇稿子被,我以为而整理一下 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

故接下,我会一一讲解这些方案的用方法和一部分案例。在用这些情节的当儿,我哉会见顺便说一些基本上线程周边产品。比如:
线程同步延时执行单例模式 等等。

文/伯恩的遗产(简书作者)
原稿链接:http://www.jianshu.com/p/0b0d9b1f1f19
著作权归作者所有,转载请联系作者获得授权,并标注“简书作者”。

Pthreads

事实上是方案不用说的,只是以来充个数,为了为大家了解一下就算好了。百度百科里是这般说之:

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
中无法执行这套方法,原因是其一函数需要传入一个函数指针
CFunctionPointer<T> 类型,但是当前 swift 无法将艺术变成此类型。听说
swift 2.0 引入一个新特征 @convention(c), 可以就 Swift 方法变成为 c
语言指针的。每当此间可以见见

那么,Pthreads 方案的多线程我就算介绍这么多,毕竟做 iOS
开发几乎未容许因此到。但是若您感兴趣的话,或者说眷恋使团结实现均等套多线程方案,从底部开始定制,那么可以去抄一下息息相关材料。

Pthreads

骨子里这个方案不用说之,只是以来充个数,为了为大家了解一下不怕哼了。百度百科里是这般说的:

POSIX线程(POSIX
threads),简称Pthreads,是线程的POSIX标准。该规范定义了创建同操纵线程的套API。在类Unix操作系统(Unix、Linux、Mac
OS X等)中,都利用Pthreads作为操作系统的线程。

简地游说,这是一模一样学在诸多操作系统及都通用的多线程API,所以移植性很强(然并卵),当然在
iOS 中呢是可的。不过就是根据 c语言
的框架,使用起来就酸爽!感受一下:

NSThread

当下套方案是通过苹果封装后底,并且完全面向对象的。所以您可一直操控线程对象,非常直观和便民。但是,它的生命周期还是待我们手动管理,所以这套方案吗是偶发用用,比如
[NSThread currentThread],它可拿走当前线程类,你虽可了解当前线程的各种性能,用于调试好好。下面来探视它的片用法。

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
中无法推行这套方法,原因是以此函数需要传入一个函数指针
CFunctionPointer<T> 类型,但是当前 swift 无法用艺术变成此类型。听说
swift 2.0 引入一个初特色 @convention(c), 可以得 Swift 方法变成为 c
语言指针的。当此处可以看看

那么,Pthreads 方案的多线程我哪怕介绍这么多,毕竟做 iOS
开发几乎未容许就此到。但是要您感兴趣的话,或者说眷恋如果协调实现均等法多线程方案,从脚开始定制,那么好错过抄一下连锁材料。

其它方

而外创建启动外,NSThread
还坐博方式,下面我列举部分周边的艺术,当然我列举的并无完全,更多措施大家可去类的定义里去押。

NSThread

即时套方案是透过苹果封装后的,并且完全面向对象的。所以您可直接操控线程对象,非常直观和有益。但是,它的生命周期还是用我们手动管理,所以这套方案也是偶然用用,比如
[NSThread currentThread],它可收获当前线程类,你就算得知晓当前线程的各种性能,用于调试好有利于。下面来看看她的有的用法。

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: 不安全,所以在 Swift
    去丢了此主意。

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

SWIFT

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(先进先出)
地取下一个,执行一个,然后抱下一个,这样一个一个底尽。

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

更新:放到并行队列的职责,GCD 也会见
FIFO的收获下,但不同之凡,它得到出来一个不怕会见坐别的线程,然后还取出来一个又放任何一个之线程。这样由获得之动作迅速,忽略不计,看起,所有的任务还是联合实施之。不过要注意,GCD
会根据系统资源控制并行的多少,所以只要任务多,它并无见面给拥有任务而推行。

虽很绕,但请圈下表:

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

Swift的法子名字跟OC的办法名都一模一样,我就算不浪费空间列举出了。

事实上,NSThread
用起来呢特别简单的,因为她便那几栽艺术。同时,我们也只有当有非常简单的光景才会就此
NSThread,
毕竟它还不够智能,不能够优雅地处理多线程中的旁高级概念。所以接下要说之始末才是着重。

创立行

  • 主队列:这是一个奇之
    串行队列。什么是主队列,大家还知吧,它用来刷新 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)
    

GCD

Grand Central Dispatch,听名字就霸道。它是苹果也多按的相运算提出的解决方案,所以会活动合理地采用再次多的CPU内核(比如双核、四审),最着重之是它见面活动管理线程的生命周期(创建线程、调度任务、销毁线程),完全不欲我们管理,我们唯有待报告干什么就推行。同时其用的呢是
c语言,不过鉴于下了
Block(Swift里称闭包),使得以起来更加有利于,而且灵活。所以多大家都应用
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 中,加入了点儿独雅重大的概念: 任务队列

  • 任务:即操作,你想使干什么,说白了即是同等段子代码,在 GCD 中不怕是一个
    Block,所以添加任务非常便民。任务来少数栽实施措施: 一道执行
    异步执行,他们中间的分别是 是否会创建新的线程

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

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

    更新
    此间说之连无准确,同步(sync)异步(async)
    的严重性分在会不见面阻塞时线程,直到 Block
    中之天职执行完毕!
    如果是 同步(sync) 操作,它见面卡住时线程并等 Block
    中的天职尽了,然后当前线程才会延续向下运行。
    如果是
    异步(async)操作,当前线程会直接通往下实施,它不会见堵塞时线程。

  • 队:用于存放任务。一共发星星点点栽队列, 阴差阳错行队列互相队列

    出错行队列 中的任务会因队列的概念 FIFO
    的执行,一个连缀一个之先进先出的拓展实施。

    更新:放到串行队列的职责,GCD 会 FIFO(先进先出)
    地取下一个,执行一个,然后拿走下一个,这样一个一个的行。

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

    更新:放到并行队列的任务,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())

答案:
只见面打印第一句子:之前 - <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 所于的线程被轧死了。剩下的一定量句代码自然不见面打印。

加上任务

值得说明的凡,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}

    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()
    在内的各种艺术。所以是意义提供给高档玩家,我在这里就是隐瞒了,等自家要用到常于研讨它们,到时刻可能会见又举行创新。

队列组

队列组可以用过多阵添加到一个组里,这样做的利是,当这组里所有的任务还尽完毕了,队列组会通过一个措施通知我们。下面是以办法,这是一个十分实用的法力。

创造行

在押罢面的情节即掌握,我们好调用一个 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, 这时该咨询了,大家将 NSOperationQueueGCD的队列
相比较就会见发现,这里没串行队列,那要自己眷恋如果10只任务在其它线程串行的履行怎么处置?

立虽是苹果封装的妙处,你不用管串行、并行、同步、异步这些名词。NSOperationQueue
有一个参数 maxConcurrentOperationCount
最酷并发数,用来设置极端多好被小只任务而实行。当你拿它们装也 1
的时刻,他无就是是串行了嘛!

NSOperationQueue
还有一个抬高任务的主意,- (void)addOperationWithBlock:(void (^)(void))block;
,这是不是同 GCD 差不多?这样即便得长一个职责交行列中了,十分利。

NSOperation 有一个不行实用的意义,那就是是长依赖。比如来 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):
    夫法的使用及达标一个同一,传入
    自打定义之面世队列(DISPATCH_QUEUE_CONCURRENT),它同达到一个措施一致的梗塞
    queue,不同的凡 这个办法还会 闭塞时线程
    若你传入的是其它的 queue, 那么其便与 dispatch_sync
    一样了。

NSOperation和NSOperationQueue

NSOperation 是苹果店对 GCD
的包,完全面向对象,所以采取起来再次好理解。 大家可以看
NSOperation 和 NSOperationQueue 分别对诺 GCD 的 任务 和 队列
。操作步骤也大好理解:

  1. 将执行的天职封装到一个 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 只是一个抽象类,所以无克封装任务。但它来 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}

    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()
    在内的各种方式。所以是职能提供被高级玩家,我当这边就背着了,等自家得为此到经常在研讨它们,到早晚或会见重举行创新。

打印结果

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() 方法

  • 主队列

    细心的同室即使见面发觉,每套多线程方案都见面生出一个主线程(当然啦,说的凡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, 这时应问了,大家以 NSOperationQueueGCD的队列
相比较就是会意识,这里没串行队列,那要自身怀念要10独任务在其余线程串行的尽怎么收拾?

及时就算是苹果封装的妙处,你绝不管串行、并行、同步、异步这些名词。NSOperationQueue
有一个参数 maxConcurrentOperationCount
最酷并发数,用来设置极端多可被有些只任务而推行。当您拿它们装为 1
的时段,他莫就是是串行了呗!

NSOperationQueue
还有一个抬高任务之措施,- (void)addOperationWithBlock:(void (^)(void))block;
,这是不是跟 GCD 差不多?这样即便好加上一个职责交行列中了,十分有利。

NSOperation 有一个死实用的力量,那就是添加依赖。比如来 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)

线程同步

所谓线程同步就是以防范多个线程抢夺和一个资源造成的数额安全题材,所祭的一模一样种办法。当然为来成百上千贯彻方式,请于生看:

  • 互斥锁
    :给要一块的代码块加一个互斥锁,就好包每次仅发一个线程访问这替码块。

    ###### 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
的代码就能够写有 Swift
的。这篇文章就老长老长了,我虽无浪费篇幅了,又非是高级中学写作文。

其它艺术

上述就是一对重点方法, 下面还有部分常用方法要大家注意:

  • 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)
    
  • 一路实施
    :我们得以运用多线程的知,把多只线程都要推行此段代码添加到与一个串行队列,这样就是落实了线程同步的定义。当然这里可以以
    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
方法。下面看 Swift 中之单例模式,在Swift中单例模式非常简单!想清楚怎么由
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 和 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];
    

自打旁线程回到主线程的措施

咱们还明白在其余线程操作就后必顶主线程更新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多配,感动好我了。花了简单天,时间跨度有硌好,所以可能有些地方及段子非连贯下段或者有地方不完,如果您看在比较费劲或者发什么地方时有发生题目,都得以于评论区告诉我,我会马上修改的。当然啦,多线程的事物吧频频这些,题目为不怕只是是单问题,不要当真。想要了解又多的事物,还得和谐去网上开息息相关材料。多省官方文档。实在是编不下了,大家好好看~。对了,看我勾勒的如此努力,不自赏的语得点个爱慕吧是不过好的。

更新:第一涂鸦放出去的早晚,有不少地方出错,很感谢有心上人提出来了。如果您盼出左的地方,一定记得凭出来,这样针对性大家都有协助。还有少数对初学者的话,遇到不晓得的主意,最好的法门就是翻开官方文档,那里是极度纯粹之,就算有几乎单单词不认得,查一下哪怕好了,不见面影响对整的知情。
自我看齐出网站转载了本人之章,但转载的恐怕有问题,而己不得不以简书上创新,所以如果假定拘留
完整版本
还是顶简书来拘禁吧:此地是地方。

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多配,感动坏我了。花了零星上,时间跨度有接触异常,所以可能略地方上段子未搭下段或者有些地方不整,如果你看正在比较为难或者有啊地方来题目,都足以在评论区告诉我,我会立马修改的。当然啦,多线程的东西吗持续这些,题目为就是只有是只问题,不要当真。想使了解再多之事物,还得好去网上开息息相关资料。多看看官方文档。实在是编造不下去了,大家好好看~。对了,看我勾勒的这样努力,不从赏的语句得点单爱呢是绝好之。

更新:第一潮放出去的时刻,有过多地方来荒唐,很谢谢有心上人提出来了。如果你瞧出错的地方,一定记得凭出来,这样针对性大家都生辅助。还有一些对初学者的话,遇到不知晓的方式,最好之方式就是是查看官方文档,那里是极纯粹之,就算出几独单词不认,查一下就是哼了,不会见影响对完全的喻。
自身顾有网站转载了本人之稿子,但转载的恐怕存在问题,而自只好于简书上创新,所以一旦一旦扣
总体版本
还是顶简书来拘禁吧:这里是地点。

相关文章