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处理同一个任务:

)[self performSelector:@selector(dosomething)

withObject:nil

after:5.0];// performSelector

)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, *NSEC_PER_SEC);
dispatch_time_t delayTime2 = dispatch_time(DISPATCH_TIME_NOW, *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");

输出结果:

-- ::19.369 Whisper[:] current task
-- ::19.370 Whisper[:] next task
-- ::21.369 Whisper[:] 2秒之后添加到队列
-- ::29.654 Whisper[:] 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,  * NSEC_PER_SEC);
    
    dispatch_time(DISPATCH_TIME_NOW,  * 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, );
        dispatch_group_t group = dispatch_group_create();
        dispatch_group_async(group, queue, ^{
        [NSThread sleepForTimeInterval:];
        NSLog(@"picture1 download complete ");
        });
        dispatch_group_async(group, queue, ^{
        [NSThread sleepForTimeInterval:];
        NSLog(@"picture2 download complete ");
        });
        dispatch_group_async(group, queue, ^{
        [NSThread sleepForTimeInterval:];
        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.737 gcdTest[:] picture1 download complete
      ::17.738 gcdTest[:12a1b] picture2 download complete
      ::18.738 gcdTest[:] picture3 download complete
      ::18.739 gcdTest[:f803] update Ui
      • 注意点:
        1. Dispatch_barrier_async: 
      • 功能:在它前面的任务执行结束后它才执行,而且它后面的任务等它执行完成之后才会执行
      • 使用方法:
      • dispatch_async(queue, ^{
        [NSThread sleepForTimeInterval:];
        NSLog(@"dispatch_async1");
        }); //第一个队列
        dispatch_async(queue, ^{
        [NSThread sleepForTimeInterval:];
        NSLog(@"dispatch_async2");
        }); 第二个队列
        dispatch_barrier_async(queue, ^{
        NSLog(@"dispatch_barrier_async");
        [NSThread sleepForTimeInterval:]; }); // barrier队列
        dispatch_async(queue, ^{
        [NSThread sleepForTimeInterval:];
        NSLog(@"dispatch_async3");
        }); // 第四个队列

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

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

      dispatch_async(queue, ^{
      [NSThread sleepForTimeInterval:];
      NSLog(@"dispatch_async1");
      }); //第一个队列
      dispatch_async(queue, ^{
      [NSThread sleepForTimeInterval:];
      NSLog(@"dispatch_async2");
      }); 第二个队列
      dispatch_barrier_async(queue, ^{
      NSLog(@"dispatch_barrier_async");
      [NSThread sleepForTimeInterval:]; }); // barrier队列
      dispatch_async(queue, ^{
      [NSThread sleepForTimeInterval:];
      NSLog(@"dispatch_async3");
      }); // 第四个队列
      • 注意点:
        1. Dispatch_sync
      • 功能: 
      • 使用方法:
      • 注意点:
        1. Dispatch_apply
      • 功能:把一项任务提交到队列中多次执行,队列可以是串行也可以是并行,dispatch_apply不会立刻返回,而是在执行完block中的任务后才会返回,是同步执行的函数。
      • 使用方法:
      1. dispatch_queue_t globalQueue = dispatch_get_global_queue(, );
        NSLog(@"current task");
        dispatch_async(globalQueue, ^{
        dispatch_queue_t applyQueue = dispatch_get_global_queue(, );
        //第一个参数,3--block执行的次数
        //第二个参数,applyQueue--block任务提交到的队列
        //第三个参数,block--需要重复执行的任务
        dispatch_apply(, applyQueue, ^(size_t index) {
        NSLog(@"current index %@",@(index));
        sleep();
        });
        NSLog(@"dispatch_apply 执行完成");
        dispatch_queue_t mainQueue = dispatch_get_main_queue();
        dispatch_async(mainQueue, ^{
        NSLog(@"回到主线程更新UI");});
        });
        NSLog(@"next task");
    1. 注意点:在主线程直接调用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);
          //提交第一个block,延时5秒打印
          dispatch_async(queue, ^{
          [NSThread sleepForTimeInterval:];
          NSLog(@"Block2 printf after 5 seconds...");});
          //提交第二个block,延时15秒打印
          dispatch_async(queue, ^{
          [NSThread sleepForTimeInterval:];
          NSLog(@"Block1 printf after 15 seconds ...");
          });
          //延时一秒
          NSLog(@"sleep 1 second...");
          [NSThread sleepForTimeInterval:];
          //挂起队列
          dispatch_suspend(queue);
          //延时10秒
          NSLog(@"sleep 10 second...");
          [NSThread sleepForTimeInterval:];
          //恢复队列
          NSLog(@"resume...");
          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. ::09.903   sleep  second...
            ::10.910 suspend...
            ::10.910 sleep second...
            ::14.908 Block1 printf after seconds...(block1持续运行)
            ::20.911 resume...
            ::35.912 Block2 printf after 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;
          
          }
          
          上一篇:oracle 11.2.0.1.0 升级 11.2.0.4.0 并 patch 到11.2.0.4.7


          下一篇:JAVAC 命令使用方法