至于iOS多线程,你看自己就算够了

多年来友好瞎打了一个私家博客,个人认为还不错,决定将制造博客的过程写下去,帮助想使构建友好博客的心上人等。

在当下首稿子中,我将为您整治一下 iOS
开发被几乎栽多线程方案,以及那个采用办法及注意事项。当然为会见让起几栽多线程的案例,在其实应用受到感受它们的区别。还有一些索要验证的凡,这首文章将会晤采取
SwiftObjective-c 两种语言教学,双语幼儿园。OK,let’s begin!

预备干活

第一,我们用在github面创建一个账号。如果你还不曾github账号,那么得于首页进行快速注册

填写完成规定信息并未还的状况下,点击下面的Sign up for
Github
按钮,然后跳反至新界面。新界面用来选择是否进行付费买github的仓库加密服务,如果您盼托管在github上面的型不是开源之,那么选择付费很有必要。

此地默认选项了free免费,我们滑动到网页下面选择绿色按钮就可登记成功了。注册成功后开展界面内,我们得以经过右下角的New按钮进行邮箱认证,认证完成后点击认证链接跳反到之界面

交了马上同步,我们博客的备选干活就到位了。


概述

就首文章被,我弗见面说基本上线程是呀、线程和过程的区分、多线程有啊用,当然我呢非见面说啊是串行、什么是互为等问题,这些我们该还知的。

当 iOS 中实际上目前出 4 套多线程方案,他们各自是:

  • Pthreads
  • NSThread
  • GCD
  • NSOperation & NSOperationQueue

就此接下,我会一一讲解这些方案的下办法及有案例。在将这些情节之早晚,我耶会见顺便说有些大多线程周边产品。比如:
线程同步延时执行单例模式 等等。

创建github博客

咱点击上图的New
repository
始建新类型,项目名称必须为github名字.github.io,比如本文中之github名称为SindriLinGithubTest,那么新仓库的名务必也SindriLinGithubTest .github.io

遵照图上之信息填写后,我们好了博客仓库的搭建,接着要拓展下一致步之配备
1、 对博客仓库进行布局

2、第一差布博客

3、创建博客页面

4、选择博客主题(生成css、html等文件帮咱构建博客,可以本着这些文件进行修改)

5、在浏览器上看SindriLinGithubTest.github.io地址

6、在博客仓库下面的文书被修改博客布局,显示内容相当。通过博客显示内容跟这些文件内容对比进行修改

当今公的博客已经搭建完毕,可以于您的好情人看了

7、怎么去我们留存的库房为?如果我们若以他人就在的主题展开博客搭建,那么我们地方创建的库将去,删除仓库要当Settings中去


Pthreads

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

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

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

高效定制主题

经过上面的章程我们创建了协调的博客,但是对未懂html/css的总人口(比如我)来说,定制博客是一个烦心的题材。然而,现在咱们不用还想不开是问题了。jekyllthemes是一个简便的静态博客网站工具,我们可于是网站上面寻找我们喜欢的主题下载后一直行使。

博主本人今天应用的模版是内的Twenty主题,点击你想使的主题,然后开展下载

下载后咱们如果召开的步调如下
1、修改主题文件称吧github名字.github.io

2、通过github工具上传到公的github仓库(注意仓库间同名的博客仓库文件要去除),如果你未曾呢未思生载github工具,那么可以参照即首文章来以命令执行上传文书及服务器

3、登录github网站改包括index.html,_config.yml等于博客布局文件(这里上污染成后github博客页面就出转移,根据页面信息及脚相应的公文中进行修改)

4、修改就博客效果


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语言函数,这是比蛋疼的,更蛋疼的是您待手动处理线程的各个状态的变换即管理生命周期,比如,这段代码虽然创立了一个线程,但连无灭绝。

域名绑定

今日博客虽然已搭建好了,但是访问地址看起连不好受的,我们纪念使透过点名的地点访问怎么处置也?我们得具有一个融洽的域名,登录万网可以开展域名购买

俺们以采购域名前输入想如果的域名进行检测是否存在,如果域名处于可进状态,我们报了名万网账号,然后把域名在购买清单,进行给付购买。博主已经购置了sindrilin.com这个域名(com价格比较net贵,各位研究购买。博主的域名是三年$149)

得域名购买之后,我们还索要对域名展开解析,使之行而和我们的博客关联在并
1、我们要进来产品管理界面,选择域名,然后对咱曾经购置的域名进行分析

2、进入github
pages界面,选择右上斗的Pages
Help
,然后选择绑定博客DNS和域名

3、进行域名解析,纪录类型为A,主机纪录包括@www个别种,记录值为者两个DNS中中一个(这里自己补偿加了少数坏解析)

4、打开github仓库,在博客仓库目录下增产文件,命名为CNAME,并且写副打之域名

5、更改博客仓库的_config.yml配置,设置url为进域名地址

6、保存配置后,点击仓库的Settings,如果出现链接地址是蓝色之,那么证明博客跟域名早已涉及好了,等待几分钟即足以经过友好请的域名进行访问


SWIFT

好遗憾,在我眼前之 swift1.2
中无法推行这套方法,原因是这函数需要传入一个函数指针
CFunctionPointer<T> 类型,但是时 swift 无法以艺术变成此类型。听说
swift 2.0 引入一个新特性 @convention(c), 可以做到 Swift 方法变成为 c
语言指针的。以这边可以观看

那么,Pthreads 方案的多线程我就介绍这么多,毕竟做 iOS
开发几乎未容许为此到。但是只要您感兴趣的话,或者说眷恋如果和谐实现均等模仿多线程方案,从脚开始定制,那么好去抄一下连锁资料。

新博客

例行来说,在我们下载的主题中来个_posts文本夹,这里面存的凡博客文章,正常而言是md(markdown)格式。我之提议是绝不去这些文件,我们的博客可以以这些文件之格式上开展修改书写。
此间我用的markdown编辑器是typora,个人认为是markdown编辑器简洁好用。选择_posts目下随便一个md文件右键使用typora打开,文件中红框勾选起来的一部分千万不要任意去,可以进行改动。如果非小心删除了也许会见招博客无法显示或者您的博客页面错乱等问题

完了博客后,直接保存在_posts文本下,然后以github for
mac,然后交到修改,点击右侧上比的sync展开文件并,再过同样会见博客就更新了。另外博客图可以在库房的images文本下下html语句进行得


NSThread

即时套方案是通过苹果封装后的,并且完全面向对象的。所以你可以直接操控线程对象,非常直观和有利于。但是,它的生命周期还是待我们手动管理,所以马上套方案吧是偶发用用,比如
[NSThread currentThread],它可博当前线程类,你就足以知道当前线程的各种性能,用于调试好方便。下面来探视它的有用法。

岂换主题

于做到点的操作之后,正常吧我们已搭建好了咱们的博客和主题,在肯定之前应为您的爱人看一下库域名确认,如果起了

顿时就算说明您的博客主题搭建失败,这个主题是没因此底。那么此时我们要去github上面的库房

遂删除github上面托管的博客仓库后,我们尚待移除本地github工具点的博客文件

右键项目 -> Remove
完了后咱们下充斥新的主题,然后按地方的法子更提交,直到我们选取的主题会访问了


缔造并启动

  • 事先创建线程类,再起步

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

更多

出于本文创建的博客服务器放在github,在拓展走访的时光加载速度可能无足够高。如果是追完美主义者,可以以万网上购得阿里的云服务器,然后搜索个见面后台开发之小伙伴等共同开并用服务器。
外资源:
markdown语法
阿里云服务器购买
笔者博客
笔者Github

文集:出日记

旁艺术

除开创建启动外,NSThread
还因博道,下面我列举部分宽广的艺术,当然我列举的连无整,更多措施大家可去类的概念里去押。

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

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

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

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

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

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

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

Swift的法子名字与OC的法子名都同样,我便无浪费空间列举出了。

骨子里,NSThread
用起来也不行简单的,因为它们便那么几栽方法。同时,我们也惟有在有些非常简单的场景才见面为此
NSThread,
毕竟她还不够智能,不可知优雅地拍卖多线程中的其余高档概念。所以接下要说的情才是第一。

GCD

Grand Central Dispatch,听名字便横。它是苹果为多对的并行运算提出的解决方案,所以会见活动合理地利用还多之CPU内核(比如双核、四核对),最重点的凡它见面活动管理线程的生命周期(创建线程、调度任务、销毁线程),完全不欲我们管理,我们才待告诉干什么就尽。同时她用的为是
c语言,不过鉴于应用了
Block(Swift里叫闭包),使得以起来更加便利,而且灵活。所以基本上大家还下
GCD
这套方案,老少咸宜,实在是住户旅行、杀人灭口,必备良药。不好意思,有接触被第二,咱们继续。

职责及行

GCD 中,加入了点滴单可怜重要之概念: 任务队列

  • 任务:即操作,你想如果干什么,说白了就是均等段代码,在 GCD 中便是一个
    Block,所以添加任务特别有益。任务来有限种植实施办法: 一齐施行
    异步执行,他们之间的分别是 是否会创建新的线程

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

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

    更新
    此处说的连无可靠,同步(sync)异步(async)
    的关键区别在于会不见面卡住时线程,直到 Block
    中的任务尽完毕!
    如果是 同步(sync) 操作,它会堵塞时线程并伺机 Block
    中之任务尽完毕,然后当前线程才见面继续朝生运作。
    如果是
    异步(async)操作,当前线程会直接向生实行,它不会见阻塞时线程。

  • 队列:用于存放任务。一共来少种植阵, 错行队列相队列

    拧行队列 中之职责会冲队列的定义 FIFO
    的实行,一个属一个底先进先出的拓实践。

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

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

更新:放到并行队列的天职,GCD 也会
FIFO的拿走下,但不同的凡,它得到出来一个即便会见放别的线程,然后又沾出来一个以放到任何一个的线程。这样由获得之动作迅速,忽略不计,看起,所有的任务都是一道实施的。不过需要小心,GCD
会根据系统资源控制并行的数码,所以一旦任务过多,它并无会见受有任务而实行。

虽说可怜绕,但要看下表:

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

创建行

  • 主队列:这是一个奇之
    串行队列。什么是主队列,大家还晓得吧,它用来刷新 UI,任何要刷新
    UI 的行事且如在主队列执行,所以一般耗时的天职还设置别的线程执行。

      //OBJECTIVE-C
      dispatch_queue_t queue = ispatch_get_main_queue();
    
      //SWIFT
      let queue = ispatch_get_main_queue()
    
  • 自己创造的班凡是自己创建的队列都是 `串行队列`。
    其中第一个参数是标识符,用于 DEBUG
    的时标识唯一的队,可以为空。大家可以看xcode的文档查看参数意义。

更新:自己好创造 串行队列, 也可创造
并行队列。看下面的代码(代码已经更新),它发生个别个参数,第一个方面已经说了,第二单才是极端要之。
第二独参数用来代表创建的序列是串行的还是并行的,传入
DISPATCH_QUEUE_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)
    

缔造任务

  • 齐任务: 不会另开线程 改:会卡住时线程 (SYNC)

    ###### OBJECTIVE-C

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

    ###### SWIFT

      dispatch_sync(<#queue#>, { () -> Void in
          //code here
          println(NSThread.currentThread())
      })
    
  • 异步任务:会另开线程 改:不见面阻塞时线程 (ASYNC)

    ###### OBJECTIVE-C

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

    ###### SWIFT

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

更新
为重新好的晓并和异步,和各种队列的施用,下面看个别单示范:

示例一:
以下代码在主线程调用,结果是啊?

NSLog("之前 - %@", NSThread.currentThread())
dispatch_sync(dispatch_get_main_queue(), { () -> Void in 
        NSLog("sync - %@", NSThread.currentThread())
})
NSLog("之后 - %@", NSThread.currentThread())

答案:
但会打印第一句:之前 - <NSThread: 0x7fb3a9e16470>{number = 1, name = main}
,然后主线程就咬死了,你可以界面及拓宽一个按钮,你便见面发觉沾不了了。
解释:
一路任务会卡住时线程,然后将 Block
中的天职放到指定的行中实施,只有当及 Block
中的职责就后才会为眼前线程继续往下运行。
那么这里的步调就是是:打印了第一句子后,dispatch_sync
立即阻塞时的主线程,然后把 Block 中的天职放到 main_queue 中,可是
main_queue
中的职责会给得下放到主线程中推行,但主线程这个时刻已为打断了,所以
Block 中之天职就无克不辱使命,它不完了,dispatch_sync
就见面直接不通主线程,这就是是死锁现象。导致主线程一直卡死。

示例二:
以下代码会来什么结果?

let queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_SERIAL)

NSLog(“之前 – %@”, NSThread.currentThread())

dispatch_async(queue, { () -> Void in
    NSLog("sync之前 - %@", NSThread.currentThread())
    dispatch_sync(queue, { () -> Void in
         NSLog("sync - %@", NSThread.currentThread())
    })
    NSLog("sync之后 - %@", NSThread.currentThread())

})

NSLog(“之后 – %@”, NSThread.currentThread())

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

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


### 队列组

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

###### OBJECTIVE-C

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

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

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

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

//4.都完成后会自动通知
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
   NSLog(@"完成 - %@", [NSThread currentThread]);
});
SWIFT
//1.创建队列组
let group = dispatch_group_create()
//2.创建队列
let queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)

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

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

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

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

打印结果

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


这些就是是 GCD 的基本功能,但是它们的力量多不止这些,等说话完 NSOperation
后,我们再度来瞧她的有旁方用途。而且,只要您想象力够长,你可结合产生再好的用法。

更新:关于GCD,还有个别独需要说的:

  • func dispatch_barrier_async(_ queue: dispatch_queue_t, _ block: dispatch_block_t):
    斯点子主要是你传入的 queue,当您传入的 queue 是通过
    DISPATCH_QUEUE_CONCURRENT 参数自己创办的 queue
    时,这个方法会阻塞这个 queue只顾是死 queue
    ,而非是死时线程
    ),一直当及之 queue
    中祛在它前面的天职都实施好后才见面起来实践好,自己实施了后,再晤收回阻塞,使这
    queue 中祛在她后的职责继续执行。
    要是您传入的是别的 queue, 那么它便同 dispatch_async 一样了。

  • func dispatch_barrier_sync(_ queue: dispatch_queue_t, _ block: dispatch_block_t):
    斯主意的使用及及一个一律,传入
    于定义的出现队列(DISPATCH_QUEUE_CONCURRENT),它同高达一个办法一致的围堵
    queue,不同之是 这个方法还见面 闭塞时线程
    苟您传入的是外的 queue, 那么其就是跟 dispatch_sync 一样了。

NSOperation和NSOperationQueue

NSOperation 是苹果公司针对 GCD
的包裹,完全面向对象,所以下起来重好明。 大家可看来
NSOperation 和 NSOperationQueue 分别针对许 GCD 的 任务 和 队列
。操作步骤也很好明:

  1. 就要执行的任务封装到一个 NSOperation 对象中。
  2. 以之任务添加到一个 NSOperationQueue 对象中。

下一场系统就见面自动在履行任务。至于共还是异步、串行还是并行请继续往下看:

加上任务

值得说明的凡,NSOperation 只是一个抽象类,所以不能够封装任务。但她发 2
只子类用于封装任务。分别是:NSInvocationOperation
NSBlockOperation 。创建一个 Operation 后,需要调用 start
方法来启动任务,它会
默认在时行同步施行。当然你吗可以当半路取消一个职责,只待调用其
cancel 方法即可。

  • NSInvocationOperation : 需要传入一个措施名。

    ###### OBJECTIVE-C

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

    ###### SWIFT

    当 Swift 构建的和谐社会里,是容不产 NSInvocationOperation
    这种不是种类安全之歹徒的。苹果如是说。此地发出连带解释

  • NSBlockOperation

    ###### OBJECTIVE-C

      //1.创建NSBlockOperation对象
      NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
          NSLog(@"%@", [NSThread currentThread]);
      }];
    
      //2.开始任务
      [operation start];
    

    ###### SWIFT

      //1.创建NSBlockOperation对象
      let operation = NSBlockOperation { () -> Void in
          println(NSThread.currentThread())
      }
    
      //2.开始任务
      operation.start()
    

    前说过这么的天职,默认会在手上线程执行。但是 NSBlockOperation
    还有一个智:addExecutionBlock: ,通过这艺术好叫 Operation
    添加多单执行 Block。这样 Operation 中之职责 会连作执行,它会
    每当主线程和另的差不多个线程 执行这些职责,注意下面的打印结果:

    ###### OBJECTIVE-C

          //1.创建NSBlockOperation对象
          NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
              NSLog(@"%@", [NSThread currentThread]);
          }];
    
          //添加多个Block
          for (NSInteger i = 0; i < 5; i++) {
              [operation addExecutionBlock:^{
                  NSLog(@"第%ld次:%@", i, [NSThread currentThread]);
              }];
          }
    
          //2.开始任务
          [operation start];
    

    ###### SWIFT

            //1.创建NSBlockOperation对象
            let operation = NSBlockOperation { () -> Void in
                NSLog("%@", NSThread.currentThread())
            }
    
            //2.添加多个Block
            for i in 0..<5 {
                operation.addExecutionBlock { () -> Void in
                    NSLog("第%ld次 - %@", i, NSThread.currentThread())
                }
            }
    
            //2.开始任务
            operation.start()
    

    ###### 打印输出

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

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

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

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

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

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

    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.任务一:下载图片
NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"下载图片 - %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:1.0];
}];

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

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

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

//5.创建队列并加入任务
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperations:@[operation3, operation2, operation1] waitUntilFinished:NO];
SWIFT
//1.任务一:下载图片
let operation1 = NSBlockOperation { () -> Void in
    NSLog("下载图片 - %@", NSThread.currentThread())
    NSThread.sleepForTimeInterval(1.0)
}

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

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

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

//5.创建队列并加入任务
let queue = NSOperationQueue()
queue.addOperations([operation3, operation2, operation1], waitUntilFinished: false)
打印结果

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

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

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

  • 留神:不可知添加相互依赖,会死锁,比如 A因B,B依赖A。
  • 得用 removeDependency 来消除因关系。
  • 可于不同的队列中因,反正就是是仗是增长到任务身上的,和行没关系。

另外办法

上述就是是有的第一方法, 下面还有一部分常用方法需要大家注意:

  • NSOperation

    BOOL executing; //判断任务是否在实践

    BOOL finished; //判断任务是否好

    void (^completionBlock)(void); //用来安完成后待实践的操作

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

    – (void)waitUntilFinished; //阻塞当前线程直到这任务履行完毕

  • NSOperationQueue

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

    – (void)cancelAllOperations; //取消队列中拥有的天职

    – (void)waitUntilAllOperationsAreFinished;
    //阻塞当前线程直到这阵中之所有任务执行完毕

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

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

好啊,到此处差不多就是讲讲得了了。当然,我称的连无整,可能发一些文化我并没有讲到,但作为常用方法,这些都够用了。不过我以此只是报您了有方法的力量,只是怎么将她们用到相当的地方,就需多多实践了。下面我会说有些关于多线程的案例,是豪门进一步什么地询问。

别用法

以就有,我会说有以及多线程知识相关的案例,可能发几怪粗略,大家早安还懂得的,不过因当时篇稿子称的凡多线程嘛,所以当尽可能的健全嘛。还有即使是,我会尽量的运多种办法实现,让大家看看中的分。

线程同步

所谓线程同步就是为了以防多独线程抢夺和一个资源造成的数量安全题材,所采用的相同种植办法。当然也发好多贯彻方式,请为下看:

  • 互斥锁
    :给需要一起的代码块加一个互斥锁,就得保每次仅来一个线程访问这个替码块。

    ###### OBJECTIVE-C

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

    ###### SWIFT

    objc_sync_enter(self)
    //需要执行的代码块
    objc_sync_exit(self)
    
  • 一块施行
    :我们得以动用多线程的知,把多个线程都使实施此段代码添加到和一个串行队列,这样就兑现了线程同步的定义。当然这里可以采取
    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];

//后续要做的事
SWIFT

此间的 swift 代码,我虽不写了,因为各个句都平等,只是语法不同而已,照在 OC
的代码就可知写有 Swift
的。这首文章已老长老长了,我不怕非浪费篇幅了,又非是高级中学写作文。

缓执行

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

  • perform

    ###### OBJECTIVE-C

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

    ###### SWIFT

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

    得利用 GCD 中的 dispatch_after 方法,OC 和 Swift
    都可行使,这里只写 OC 的,Swift 的是同等的。

    ###### OBJECTIVE-C

    // 创建队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    // 设置延时,单位秒
    double delay = 3; 
    
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delay * NSEC_PER_SEC)), queue, ^{
      // 3秒后需要执行的任务
    });
    
  • NSTimer

    NSTimer
    是iOS中之一个计时器类,除了延迟执行还有众多为此法,不过此直说延迟执行的用法。同样只有写
    OC 版的,Swift 也是均等的。

    ###### OBJECTIVE-C

    [NSTimer scheduledTimerWithTimeInterval:3.0 target:self selector:@selector(run:) userInfo:@"abc" repeats:NO];
    

单例模式

关于什么是单例模式,我吗不多说,我特说说一般怎么落实。在 Objective-C
中,实现单例的法子都十分具体了,虽然来别的方法,但是一般还是故一个标准的主意了,下面来探视。

OBJECTIVE-C
@interface Tool : NSObject <NSCopying>

+ (instancetype)sharedTool;

@end

@implementation Tool

static id _instance;

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

    return _instance;
}

@end

此间用将单例模式,是以其中使用了 GCD 的 dispatch_once
方法。下面看 Swift 中的单例模式,在Swift中单例模式非常简单!想明白怎么从
OC
那么复杂的不二法门成为下面的写法的,吁看这里

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

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

打其它线程回到主线程的法子

俺们还知晓在外线程操作就后必须顶主线程更新UI。所以,介绍完所有的多线程方案后,我们来看望发生什么方法可回主线程。

  • NSThread

    //Objective-C
    [self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:NO];
    
    //Swift
    //swift 取消了 performSelector 方法。
    
  • GCD

    //Objective-C
    dispatch_async(dispatch_get_main_queue(), ^{
    
    });
    
    //Swift
    dispatch_async(dispatch_get_main_queue(), { () -> Void in
    
    })
    
  • NSOperationQueue

    //Objective-C
    [[NSOperationQueue mainQueue] addOperationWithBlock:^{
    
    }];
    
    //Swift
    NSOperationQueue.mainQueue().addOperationWithBlock { () -> Void in
    
    }
    

总结

好的吧,总算写了了,纯手敲6k多配,感动好我了。花了片天,时间跨度有硌十分,所以可能略地方及段子非接入下段或者部分地方不完整,如果您看在比较艰难或者来什么地方有题目,都可以评论区告诉我,我会立马修改的。当然啦,多线程的物吗不止这些,题目为便不过是独问题,不要当真。想只要打听又多的物,还得自己失去网上开息息相关材料。多看看官方文档。实在是无中生有不下去了,大家好好看~。对了,看自己写的这样努力,不起赏的言辞得点个喜吗是极度好的。

更新:第一不行放出去的时节,有很多地方产生错,很谢谢有意中人提出来了。如果你相有左的地方,一定记得凭出来,这样对大家都有帮带。还有某些对初学者的话,遇到不知道的主意,最好之主意尽管是翻开官方文档,那里是极度规范之,就算出几单单词不认识,查一下哪怕好了,不见面影响对整的亮。
自己看看出网站转载了自身之篇章,但转载的或有问题,而己不得不以简书上创新,所以如果假定拘留
完版本
还是顶简书来拘禁吧:此地是地方。