首页 > 代码库 > iOS学习之GCD

iOS学习之GCD

多线程编程

线程定义:一个CPU执行的CPU命令 列一条无分叉的路径就叫线程

多线程:执行多个不同的CPU命令 有多条路径

线程的使用:主线程(又叫作UI线程)主要任务是处理UI事件,显示和刷新UI,(只有主线程有直接修改UI的能力)耗时的操作放在子线程(又叫作后台线程、异步线程)。

多线程容易引发的编程问题:

  1. 数据竞争:多个线程更新相同的资源会导致数据不一致
  2. 死锁:停止等待事件的线程会导致多个线程相互持续等待
  3. 太多线程会消耗大量内存
  4. Thread Safe(线程安全):一段线程安全的代码(对象),可以同时被多个线程或并发的任务调度,不会产生问题,非线程安全的只能按次序被访问。

多线程优点:在需要常实际处理方法放到其他线程中,让其他线程处理,主线程不处理

GCD之前的多线程方法:NSThread, NSOperationQueue, NSInvocationOperation

GCD:Grand Central Dispatch:异步执行任务的技术。

没有使用GCD时,当app被按home键退出后,app仅有最多5秒钟的时候做一些保存或清理资源的工作。但是在使用GCD后,app最多有10分钟的时间在后台长久运行。这个时间可以用来做清理本地缓存,发送统计数据等工作。

方法优缺点分析:

  1. NSThread (抽象层次:低)
  • 优点:轻量级,简单易用,可以直接操作线程对象
  • 缺点: 需要自己管理线程的生命周期,线程同步。线程同步对数据的加锁会有一定的系统开销。
  1. Cocoa NSOperation(抽象层次:中)
  • 优点:不需要关心线程管理,数据同步的事情,可以把精力放在学要执行的操作上。基于GCD,是对GCD 的封装,比GCD更加面向对象
  • 缺点: NSOperation是个抽象类,使用它必须使用它的子类,可以实现它或者使用它定义好的两个子类NSInvocationOperation、NSBlockOperation。
  1. GCD抽象层次:高)
  • 优点:是 Apple 开发的一个多核编程的解决方法,简单易用,效率高,速度快,基于C语言,更底层更高效,并且不是Cocoa框架的一部分,自动管理线程生命周期(创建线程、调度任务、销毁线程)。
  • 缺点: 使用GCD的场景如果很复杂,就有非常大的可能遇到死锁问题。

GCD的优势

  1. GCD是苹果公司为多核的并行运算提出的解决方案
  2. GCD会自动利用更多的CPU内核(比如双核、四核)
  3. GCD会自动管理线程的生命周期(创建线程、调度任务、销毁线程)
  4. 程序员只需要告诉GCD想要执行什么任务,不需要编写任何线程管理代码

在GCD之前CoCoa框架提供了NSObject类的 performSelectorInBackgroud:withObject实例方法和performSelectorOnMainThread实例方法。

  • PerformSelector在内存管理方面会很容易有疏失,它无法确定将要执行的selector具体是什么,所以ARC没办法插入适当的内存管理方法

SEL selector;

If(    ){

Selector=@ selector(newObject)}

Else if(){
Selector=@ selector(copy)}

Else {
Selector=@ selector(somesasr)}

Id ret=[object performSelector:selector // 这样编译器不知道将要执行的seletor是哪个,必须到运行期才能确定,ARC没办法插入适当的内存管理方法。会出现错误警告。

];

//前两个需要自己释放,后面一个不需要自己释放,使用ARC会出现错误警告,不使用ARC很容易忽视掉,就算使用静态分析其,也难侦测到

  • 处理的东西太过于局限,返回值类型及发送给方法的参数个数都受到限制。
  • 如果想要把任务放在另一个线程上执行,最好不要用performSelector方法,应该封装到block中,然后调用GCD来实现。

performSelector跟GCD处理同一个任务:

1)[self performSelector:@selector(dosomething)

withObject:nil

after:5.0];// performSelector

2)dispatch_time_t time=dispatch_time(DISPATCH_TIME_NOW,

(int64_t)(5.0*NSEC_PER_SEC));

Dispatch_after(time,dispatch_get_main_queue(),^(void){
[self doSomething]; });//GCD

 

 

 

 

 

 

系统提供的Dispatch方法:

  1. 后台执行:

dispatch_async(dispatch_get_global_queue(0,0),^{

//something

});

  1. 主线程执行:

dispatch_async(dispatch_get_main_queue(),^{

//something

});

  1. 一次性执行:dispatch_once保证在app运行期间,block中的代码只执行一次
  • 经典使用场景---单例
  • 单例对象ShareManager的定义:

  Static dispatch_once_t onceToken;

dispatch_once(&onceToken ,^{

//something

});

  1. 延迟2秒执行:

Double delayInSeconds=2.0;

Dispatch_time_t popTime=dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC);

Dispatch_after(popTime, dispatch_get_main_queue(),^(void){

// onceToken

});

  1. 自定义执行:

要自定义queue可以用dispatch_queue_create

 

祥解GCD 的API

说明:只要将想执行的任务加入到适当的Dispatch Queue中。

两种Dispatch Queue:(Concurrent Dispatch Queue)

      

  1. Serial Dispatch Queue串行队列(图1): 让任务一个接着一个地执行(一个任务执行完毕后,再执行下一个任务)

Serial Dispatch Queue太多容易消耗太多内存。

所以只在可能数据竞争时使用Serial Dispatch Queue。

  1. Concurrent Dispatch Queue并发队列(图2):不等待现在执行中处理结束(可以让多个任务并发(同时)执行(自动开启多个线程同时执行任务)并发功能只有在异步(dispatch_async)函数下才有效)一个线程可同时处理多个任务。在不发生数据竞争时都可用。
    1. Dispatch_queue_create
  • 功能:创建自定义列队
  • 使用方法:dispatch_queue_t  dispatch_queue_create(const char *label,  dispatch_queue_attr_t attr); // 队列名称, 队列属性,一般用NULL

dispatch_queue_t myQueue =dispatch_queue_create(com.expample.www,DISPATCH_QUEUE_CONCURRENT);

释放:dispatch_release(myQueue);

  • 注意点:队列名称推荐使用应用程序ID的逆序全程域名(FQDN,fully qualified domain name)如:com.expample.www

由于在Xcode和Instruments的调试器中队列名称被用于Dispatch Queue名称表示。可以方便寻找。

通过Dispatch Queue创建的对列在结束使用时候要使用dispatch_release释放。

    1. Main Dispatch Queue/ Global Dispatch Queue
  1. Main Dispatch Queue属于Serial Dispatch Queue 类型。
  2. Global Dispatch Queue属于 Concurrent Dispatch Queue类型,有四种优先级:High priority(高优先级)、Default priority(默认优先级),Low priority(低优先级),Background priority(后台优先级)
    1. Dispatch_after
  • 功能:让任务延时添加到队列,将一个Block在特定的延时以后,加入到指定的队列中,不是在特定的时间后立即运行
  • 使用方法:
    • dispatch_time_t delayTime3 = dispatch_time(DISPATCH_TIME_NOW, 3*NSEC_PER_SEC);
    • dispatch_time_t delayTime2 = dispatch_time(DISPATCH_TIME_NOW, 2*NSEC_PER_SEC);
    • dispatch_queue_t mainQueue = dispatch_get_main_queue();
    • NSLog(@"current task");
    • dispatch_after(delayTime3, mainQueue, ^{
    •   NSLog(@"10秒之后添加到队列");
    • });
    • dispatch_after(delayTime2, mainQueue, ^{
    •   NSLog(@"2秒之后添加到队列");
    • });
    • NSLog(@"next task");

输出结果:

    • 2015-11-19 15:50:19.369 Whisper[2725:172593] current task
    • 2015-11-19 15:50:19.370 Whisper[2725:172593] next task
    • 2015-11-19 15:50:21.369 Whisper[2725:172593] 2秒之后添加到队列
    • 2015-11-19 15:50:29.654 Whisper[2725:172593] 3秒之后添加到队列
  • 注意点:dispatch_after只是延时提交block,并不是延时后立即执行

 

    1. dispatch_time_t
  • 功能: 创建延时时间

使用方法:dispatch_time_t dispatch_time ( dispatch_time_t when, int64_t delta ); 

第一个参数一般是DISPATCH_TIME_NOW,表示从现在开始。

那么第二个参数就是真正的延时的具体时间。delta参数是“纳秒

    • dispatch_time_t delayTime3 = dispatch_time(DISPATCH_TIME_NOW, 3*NSEC_PER_SEC);

 

注意点:延时1秒可以写成如下几种:

dispatch_time(DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC);

dispatch_time(DISPATCH_TIME_NOW, 1000 * USEC_PER_SEC);

dispatch_time(DISPATCH_TIME_NOW, USEC_PER_SEC * NSEC_PER_USEC);

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

  • NSEC_PER_SEC,每秒有多少纳秒。
  • USEC_PER_SEC,每秒有多少毫秒。(注意是指在纳秒的基础上)
  • NSEC_PER_USEC,每毫秒有多少纳秒。
    1. Dispatch Group:dispatch_group_async
  • 功能:当遇到需要执行多个线程并发执行,然后等多个线程都结束之后,再汇总执行结果时可以用group queue(同时下载多个图片,所有图片下载完成之后去更新UI(需要回到主线程)或者去处理其他任务(可以是其他线程队列)。)
  • 使用方法:
    • dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);  
    • dispatch_group_t group = dispatch_group_create();  
    • dispatch_group_async(group, queue, ^{  
    •     [NSThread sleepForTimeInterval:1];  
    •     NSLog(@"picture1 download complete ");  
    • });  
    • dispatch_group_async(group, queue, ^{  
    •     [NSThread sleepForTimeInterval:2];  
    •     NSLog(@"picture2 download complete ");  
    • });  
    • dispatch_group_async(group, queue, ^{  
    •     [NSThread sleepForTimeInterval:3];  
    •     NSLog(@"picture3 download complete");  
    • });  
    • dispatch_group_notify(group, dispatch_get_main_queue(), ^{  
    •     NSLog(@"update Ui");  
    • });  
    • dispatch_release(group);  

运行思路:使用函数dispatch_group_create创建dispatch group,然后使用函数dispatch_group_async来将要执行的block任务提交到一个dispatch queue。同时将他们添加到一个组,等要执行的block任务全部执行完成(三张图片都下载完成)之后,使用dispatch_group_notify函数接收完成时的消息(回到主线程:更新UI)。

运行结果:

16:04:16.737 gcdTest[43328:11303] picture1 download complete
16:04:17.738 gcdTest[43328:12a1b] picture2 download complete
16:04:18.738 gcdTest[43328:13003] picture3 download complete
16:04:18.739 gcdTest[43328:f803] update Ui

  • 注意点:
    1. Dispatch_barrier_async: 
  • 功能:在它前面的任务执行结束后它才执行,而且它后面的任务等它执行完成之后才会执行
  • 使用方法:
    1. dispatch_async(queue, ^{  
    2.     [NSThread sleepForTimeInterval:2];  
    3.     NSLog(@"dispatch_async1");  
    4. });  //第一个队列
    5. dispatch_async(queue, ^{  
    6.     [NSThread sleepForTimeInterval:4];  
    7.     NSLog(@"dispatch_async2");  
    8. });  第二个队列
    9. dispatch_barrier_async(queue, ^{  
    10.     NSLog(@"dispatch_barrier_async");  
    11.     [NSThread sleepForTimeInterval:4];  
    12.   
    13. });  // barrier队列
    14. dispatch_async(queue, ^{  
    15.     [NSThread sleepForTimeInterval:1];  
    16.     NSLog(@"dispatch_async3");  
    17. });  // 第四个队列

运行思路:第一二个block同时运行,等一二block都运行完开始运行barrier队列,barrier队列运行完后,运行第四个block

运行结果:16:20:31开始运行

 16:20:33.967 gcdTest[45547:11203] dispatch_async1

16:20:35.967 gcdTest[45547:11303] dispatch_async2

16:20:35.967 gcdTest[45547:11303] dispatch_barrier_async

16:20:40.970 gcdTest[45547:11303] dispatch_async3

  • 注意点:
    1. Dispatch_sync
  • 功能: 
  • 使用方法:
  • 注意点:
    1. Dispatch_apply
  • 功能:把一项任务提交到队列中多次执行,队列可以是串行也可以是并行,dispatch_apply不会立刻返回,而是在执行完block中的任务后才会返回,是同步执行的函数。
  • 使用方法:
    1. dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);
    2. NSLog(@"current task");
    3. dispatch_async(globalQueue, ^{
    4. dispatch_queue_t applyQueue = dispatch_get_global_queue(0, 0);
    5. //第一个参数,3--block执行的次数
    6. //第二个参数,applyQueue--block任务提交到的队列
    7. //第三个参数,block--需要重复执行的任务
    8. dispatch_apply(3, applyQueue, ^(size_t index) {
    9.       NSLog(@"current index %@",@(index));
    10.       sleep(1);
    11. });
    12. NSLog(@"dispatch_apply 执行完成");
    13. dispatch_queue_t mainQueue = dispatch_get_main_queue();
    14. dispatch_async(mainQueue, ^{
    15.       NSLog(@"回到主线程更新UI");});
    16. });
    17. NSLog(@"next task");
  • 注意点:在主线程直接调用dispatch_apply会阻塞主线程,为了不阻塞主线程,一般把dispatch_apply放在异步队列中调用,然后执行完成后通知主线程
    1. Dispatch_suspend/dispatch_resume
  • 功能:提供了“挂起、恢复”队列的功能,简单来说,就是可以暂停、恢复队列上的任务。但是这里的“挂起”,并不能保证可以立即停止队列上正在运行的block

使用方法:

    1. dispatch_queue_t queue = dispatch_queue_create("me.tutuge.test.gcd", DISPATCH_QUEUE_SERIAL);
    2. //提交第一个block,延时5秒打印
    3. dispatch_async(queue, ^{
    4.     [NSThread sleepForTimeInterval:5];
    5.     NSLog(@"Block2 printf after 5 seconds...");});
    6. //提交第二个block,延时15秒打印
    7. dispatch_async(queue, ^{
    8.     [NSThread sleepForTimeInterval:15];
    9.     NSLog(@"Block1 printf after 15 seconds ...");
    10. });
    11. //延时一秒
    12. NSLog(@"sleep 1 second...");
    13. [NSThread sleepForTimeInterval:1];
  1. //挂起队列                         
  2. dispatch_suspend(queue);
  3. //延时10秒                
  4. NSLog(@"sleep 10 second...");
  5. [NSThread sleepForTimeInterval:10];
  6. //恢复队列            
  7. NSLog(@"resume...");
  8. dispatch_resume(queue);

运行思路:

1.block开始运行(延时五秒打印),同时打印sleep 1 second...,

2.遇到延时一秒命令延时了一秒,运行到挂起命令,队列将暂停,但是正在运行的block1持续运行,在运行期五秒后打印Block1 printf after 5 seconds...

3.运行完block1,队列真正暂停。然后运行打印 sleep 10 second...之后到延时十秒命令,延时了十秒,十秒后运行打印;resume...;到恢复队列命令,队列恢复运行(block2开始运行),15秒后block2运行完毕,打印Block2 printf after 15 seconds ...

所以在dispatch_suspend挂起队列后,第一个block还是在运行,并且正常输出。

运行结果:

    1. 00:32:09.903   sleep 1 second...
    2. 00:32:10.910  suspend...
    3. 00:32:10.910  sleep 10 second...
    4. 00:32:14.908  Block1 printf after 5 seconds...(block1持续运行)
    5. 00:32:20.911  resume...
    6. 00:32:35.912  Block2 printf after 15 seconds ...

注意点:dispatch_suspend并不会立即暂停正在运行的block,而是在当前block执行完成后,暂停后续的block执行。所以想暂停正在队列上运行的block时,还是不要用dispatch_suspend

 

    1. Dispatch_once
  • 功能:被广泛使用在单例、缓存等代码中,用以保证在初始化时执行一次某任务。在单线程程序中毫无意义,但在多线程程序中,其低负载、高可依赖性、接口简单等特性
  • 使用方法:
  1. static dispatch_once_t once;
  2. dispatch_once(&once, ^{
  3.    //单例代码 
  4. });
  • 注意点:dispatch_once_t必须是全局或static

 

让程序在后台长久运行的示例代码:

@property (assign, nonatomic) UIBackgroundTaskIdentifier backgroundUpdateTask;

 

// AppDelegate.m文件

- (void)applicationDidEnterBackground:(UIApplication *)application

{

    [self beingBackgroundUpdateTask];

    // 在这里加上你需要长久运行的代码

    [self endBackgroundUpdateTask];

}

 

- (void)beingBackgroundUpdateTask

{

    self.backgroundUpdateTask = [[UIApplication sharedApplication] beginBackgroundTaskWithExpirationHandler:^{

        [self endBackgroundUpdateTask];

    }];

}

 

- (void)endBackgroundUpdateTask

{

    [[UIApplication sharedApplication] endBackgroundTask: self.backgroundUpdateTask];

    self.backgroundUpdateTask = UIBackgroundTaskInvalid;

}

 

iOS学习之GCD