开创个人博客详细流程葡京网上娱乐场

最近协调瞎搞了一个个体博客,个人认为还不易,决定把创建博客的长河写下去,协助想要构建协调博客的情人们。

在这篇小说中,我将为你整理一下 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)(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)(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)(Swift)的。那篇小说已经老长老长了,我就不浪费篇幅了,又不是高级中学写作文。

延期执行

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

  • perform

    ###### OBJECTIVE-C

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

    ###### SWIFT

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

    可以动用 GCD 中的 dispatch_after 方法,OC 和 Swift(Swift)都可以应用,这里只写 OC 的,斯维夫特(Swift)(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

    NS提姆(Tim)er
    是iOS中的一个计时器类,除了延迟执行还有众多用法,然而这里直说延迟执行的用法。同样只写
    OC 版的,Swift(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多字,感动死我了。花了两天,时间跨度有点大,所以可能有点地方上段不接下段或者部分地点不完全,尽管您看着相比为难或者有什么样地点有问题,都可以在评论区告诉我,我会立即修改的。当然啦,多线程的东西也持续这么些,题目也就只是个问题,不要当真。想要了然更多的东西,还得和谐去网上挖掘息息相关资料。多看看官方文档。实在是编不下去了,我们好美观~。对了,看本身写的如此努力,不打赏的话得点个喜欢也是极好的。

更新:第一次放出去的时候,有诸多地点有错误,很感谢有心上人提议来了。如若您看到有荒唐的地点,一定记得指出来,那样对我们都有协助。还有一些对初学者的话,遭遇不懂的主意,最好的法门就是翻开官方文档,这里是最纯正的,尽管有多少个单词不认得,查一下就好了,不会影响对完全的领会。
自身见到有网站转载了本人的篇章,但转载的或是存在问题,而自己只可以在简书上更新,所以只要要看
完整版本
如故到简书来看吗:此间是地点