iOS中GCD的使用小结

原创 2015年11月20日 15:55:23

本篇博客共分以下几个模块来介绍GCD的相关内容:

  • 多线程相关概念
  • 多线程编程技术的优缺点比较?
  • GCD中的三种队列类型
  • The main queue(主线程串行队列)
  • Global queue(全局并发队列)
  • Custom queue (自定义队列)
  • Group queue (队列组)
  • GCD中一些系统提供的常用dispatch方法

多线程相关概念

  1. 进程与线程
    • 进程概念: 进程是程序在计算机上的一次执行活动,打开一个app,就开启了一个进程,可包含多个线程。
    • 线程概念: 独立执行的代码段,一个线程同时间只能执行一个任务,反之多线程并发就可以在同一时间执行多个任务。
    • iOS程序中,主线程(又叫作UI线程)主要任务是处理UI事件,显示和刷新UI,(只有主线程有直接修改UI的能力)耗时的操作放在子线程(又叫作后台线程、异步线程)。在iOS中开子线程去处理耗时的操作,可以有效提高程序的执行效率,提高资源利用率。但是开启线程会占用一定的内存,(主线程的堆栈大小是1M,第二个线程开始都是512KB,并且该值不能通过编译器开关或线程API函数来更改)降低程序的性能。所以一般不要同时开很多线程。
  2. 线程相关
    • 同步线程:同步线程会阻塞当前线程去执行线程内的任务,执行完之后才会反回当前线程。
    • 异步线程:异步线程不会阻塞当前线程,会开启其他线程去执行线程内的任务。
    • 串行队列:线程任务按先后顺序逐个执行(需要等待队列里面前面的任务执行完之后再执行新的任务)。
    • 并发队列:多个任务按添加顺序一起开始执行(不用等待前面的任务执行完再执行新的任务),但是添加间隔往往忽略不计,所以看着像是一起执行的。
    • 并发VS并行:并行是基于多核设备的,并行一定是并发,并发不一定是并行。
  3. 多线程中会出现的问题
    • Critical Section(临界代码段)
      指的是不能同时被两个线程访问的代码段,比如一个变量,被并发进程访问后可能会改变变量值,造成数据污染(数据共享问题)。
    • Race Condition (竞态条件)
      当多个线程同时访问共享的数据时,会发生争用情形,第一个线程读取改变了一个变量的值,第二个线程也读取改变了这个变量的值,两个线程同时操作了该变量,此时他们会发生竞争来看哪个线程会最后写入这个变量,最后被写入的值将会被保留下来。
    • Deadlock (死锁)
      两个(多个)线程都要等待对方完成某个操作才能进行下一步,这时就会发生死锁。
    • Thread Safe(线程安全)
      一段线程安全的代码(对象),可以同时被多个线程或并发的任务调度,不会产生问题,非线程安全的只能按次序被访问。
    • 所有Mutable对象都是非线程安全的,所有Immutable对象都是线程安全的,使用Mutable对象,一定要用同步锁来同步访问(@synchronized)。
    • 互斥锁:能够防止多线程抢夺造成的数据安全问题,但是需要消耗大量的资源
    • 原子属性(atomic)加锁
      • atomic: 原子属性,为setter方法加锁,将属性以atomic的形式来声明,该属性变量就能支持互斥锁了。
      • nonatomic: 非原子属性,不会为setter方法加锁,声明为该属性的变量,客户端应尽量避免多线程争夺同一资源。
    • Context Switch (上下文切换)
      当一个进程中有多个线程来回切换时,context switch用来记录执行状态,这样的进程和一般的多线程进程没有太大差别,但会产生一些额外的开销。

多线程编程技术的优缺点比较

  1. NSThread (抽象层次:低)
    • 优点:轻量级,简单易用,可以直接操作线程对象
    • 缺点: 需要自己管理线程的生命周期,线程同步。线程同步对数据的加锁会有一定的系统开销。
  2. Cocoa NSOperation (抽象层次:中)
    • 优点:不需要关心线程管理,数据同步的事情,可以把精力放在学要执行的操作上。基于GCD,是对GCD 的封装,比GCD更加面向对象
    • 缺点: NSOperation是个抽象类,使用它必须使用它的子类,可以实现它或者使用它定义好的两个子类NSInvocationOperation、NSBlockOperation.
  3. GCD 全称Grand Center Dispatch (抽象层次:高)

    • 优点:是 Apple 开发的一个多核编程的解决方法,简单易用,效率高,速度快,基于C语言,更底层更高效,并且不是Cocoa框架的一部分,自动管理线程生命周期(创建线程、调度任务、销毁线程)。
    • 缺点: 使用GCD的场景如果很复杂,就有非常大的可能遇到死锁问题。

      GCD抽象层次最高,使用也简单,因此,苹果也推荐使用GCD

GCD中的三种队列类型

GCD编程的核心就是dispatch队列,dispatch block的执行最终都会放进某个队列中去进行。

  1. The main queue(主线程串行队列): 与主线程功能相同,提交至Main queue的任务会在主线程中执行,
    • Main queue 可以通过dispatch_get_main_queue()来获取。
  2. Global queue(全局并发队列): 全局并发队列由整个进程共享,有高、中(默认)、低、后台四个优先级别。
    • Global queue 可以通过调用dispatch_get_global_queue函数来获取(可以设置优先级)
  3. Custom queue (自定义队列): 可以为串行,也可以为并发。
    • Custom queue 可以通过dispatch_queue_create()来获取;
  4. Group queue (队列组):将多线程进行分组,最大的好处是可获知所有线程的完成情况。
    • Group queue 可以通过调用dispatch_group_create()来获取,通过dispatch_group_notify,可以直接监听组里所有线程完成情况。

gcd中相关函数的使用一般都是以dispatch开头

The main queue(主线程串行队列)

dispatch_sync 同步执行任务函数,不会开启新的线程,dispatch_async 异步执行任务函数,会开启新的线程

  1. 获取主线程串行队列
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
  2. 主线程串行队列同步执行任务,在主线程运行时,会产生死锁
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    dispatch_sync(mainQueue,^{
    NSLog("MainQueue");            
    });
    程序一直处于等待状态,block中的代码将执行不到
  3. 主线程串行队列异步执行任务,在主线程运行,不会产生死锁。
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    dispatch_async(mainQueue,^{
    NSLog("MainQueue");            
    });
    程序正常运行,block中的代码正常运行
  4. 从子线程,异步返回主线程更新UI<这种使用方式比较多>
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_async(globalQueue, ^{
        //子线程异步执行下载任务,防止主线程卡顿
        NSURL *url = [NSURL URLWithString:@"http://www.baidu.com"];
        NSError *error;
        NSString *htmlData = [NSString stringWithContentsOfURL:url encoding:NSUTF8StringEncoding error:&error];
        if (htmlData != nil) {
            dispatch_queue_t mainQueue = dispatch_get_main_queue();
             //异步返回主线程,根据获取的数据,更新UI
            dispatch_async(mainQueue, ^{
                NSLog(@"根据更新UI界面");
            });
        } else {
            NSLog(@"error when download:%@",error);
        }
    });
    主线程串行队列由系统默认生成的,所以无法调用dispatch_resume()和dispatch_suspend()来控制执行继续或中断。

Global queue(全局并发队列)

耗时的操作,比如读取网络数据,IO,数据库读写等,我们会在另外一个线程中处理这些操作,然后通知主线程更新界面

  1. 获取全局并发队列
    //程序默认的队列级别,一般不要修改,DISPATCH_QUEUE_PRIORITY_DEFAULT == 0
    dispatch_queue_t globalQueue1 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //HIGH
    dispatch_queue_t globalQueue2 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
    //LOW
    dispatch_queue_t globalQueue3 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
    //BACKGROUND
    dispatch_queue_t globalQueue4 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
  2. 全局并发队列同步执行任务,在主线程执行会导致页面卡顿。
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    NSLog(@"current task");
    dispatch_sync(globalQueue, ^{
        sleep(2.0);
        NSLog(@"sleep 2.0s");
    });
    NSLog(@"next task");
    控制台输出如下:
    2015-11-18 15:51:45.550 Whisper[33152:345023] current task
    2015-11-18 15:51:47.552 Whisper[33152:345023] sleep 2.0s
    2015-11-18 15:51:47.552 Whisper[33152:345023] next task
    2s钟之后,才会执行block代码段下面的代码。
  3. 全局并发队列异步执行任务,在主线程运行,会开启新的子线程去执行任务,页面不会卡顿。
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    NSLog(@"current task");
    dispatch_async(globalQueue, ^{
        sleep(2.0);
        NSLog(@"sleep 2.0s");
    });
    NSLog(@"next task");
    控制台输出如下:
    2015-11-18 15:50:14.999 Whisper[33073:343781] current task
    2015-11-18 15:50:15.000 Whisper[33073:343781] next task
    2015-11-18 15:50:17.004 Whisper[33073:343841] sleep 2.0s
    主线程不用等待2s钟,继续执行block代码段后面的代码。
  4. 多个全局并发队列,异步执行任务。
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    NSLog(@"current task");
    dispatch_async(globalQueue, ^{
        NSLog(@"最先加入全局并发队列");
    });
    dispatch_async(globalQueue, ^{
        NSLog(@"次加入全局并发队列");
    });
    NSLog(@"next task");
    控制台输出如下:
    2015-11-18 16:54:52.202 Whisper[39827:403208] current task
    2015-11-18 16:54:52.203 Whisper[39827:403208] next task
    2015-11-18 16:54:52.205 Whisper[39827:403309] 最先加入全局并发队列
    2015-11-18 16:54:52.205 Whisper[39827:403291] 次加入全局并发队列
    异步线程的执行顺序是不确定的。几乎同步开始执行
    全局并发队列由系统默认生成的,所以无法调用dispatch_resume()和dispatch_suspend()来控制执行继续或中断。

Custom queue (自定义队列)

  1. 自定义串行队列

    • 获取自定义串行队列

      dispatch_queue_t serialQueue = dispatch_queue_create("com.dullgrass.serialQueue", DISPATCH_QUEUE_SERIAL);
      NSLog(@"%s",dispatch_queue_get_label(conCurrentQueue)) ;
    • 控制台输出:

      2015-11-19 11:05:34.469 Whisper[1223:42960] com.dullgrass.serialQueue

      dispatch_queue_create(const char *label, dispatch_queue_attr_t attr)函数中第一个参数是给这个queue起的标识,这个在调试的可以看到是哪个队列在执行,或者在crash日志中,也能做为提示。第二个是需要创建的队列类型,是串行的还是并发的

    • 自定义串行队列同步执行任务

      dispatch_queue_t serialQueue = dispatch_queue_create("com.dullgrass.serialQueue", DISPATCH_QUEUE_SERIAL);
      NSLog(@"current task");
      dispatch_sync(serialQueue, ^{
      NSLog(@"最先加入自定义串行队列");
      sleep(2);
      });
      dispatch_sync(serialQueue, ^{
      NSLog(@"次加入自定义串行队列");
      });
      NSLog(@"next task");
    • 控制台输出:

      2015-11-18 17:09:40.025 Whisper[40241:416296] current task
      2015-11-18 17:09:40.027 Whisper[40241:416296] 最先加入自定义串行队列
      2015-11-18 17:09:43.027 Whisper[40241:416296] 次加入自定义串行队列
      2015-11-18 17:09:43.027 Whisper[40241:416296] next task

      当前线程等待串行队列中的子线程执行完成之后再执行,串行队列中先进来的子线程先执行任务,执行完成后,再执行队列中后面的任务。

    • 自定义串行队列嵌套执行同步任务,产生死锁

      dispatch_queue_t serialQueue = dispatch_queue_create("com.dullgrass.serialQueue", DISPATCH_QUEUE_SERIAL);
      dispatch_sync(serialQueue, ^{   //该代码段后面的代码都不会执行,程序被锁定在这里
      NSLog(@"会执行的代码");
      dispatch_sync(serialQueue, ^{
         NSLog(@"代码不执行");
      });
      });
    • 异步执行串行队列,嵌套同步执行串行队列,同步执行的串行队列中的任务将不会被执行,其他程序正常执行

      dispatch_queue_t serialQueue = dispatch_queue_create("com.dullgrass.serialQueue", DISPATCH_QUEUE_SERIAL);
      dispatch_async(serialQueue, ^{
      NSLog(@"会执行的代码");
      dispatch_sync(serialQueue, ^{
         NSLog(@"代码不执行");
      });
      });

      注意不要嵌套使用同步执行的串行队列任务

  2. 自定义并发队列

    • 获取自定义并发队列
      dispatch_queue_t conCurrentQueue =   dispatch_queue_create("com.dullgrass.conCurrentQueue", DISPATCH_QUEUE_CONCURRENT);
    • 自定义并发队列执行同步任务
      dispatch_queue_t conCurrentQueue = dispatch_queue_create("com.dullgrass.conCurrentQueue", DISPATCH_QUEUE_CONCURRENT);
      NSLog(@"current task");
      dispatch_sync(conCurrentQueue, ^{
         NSLog(@"先加入队列");
      });
      dispatch_sync(conCurrentQueue, ^{
         NSLog(@"次加入队列");
      });
      NSLog(@"next task");
    • 控制台输出如下:
      2015-11-19 10:36:23.259 Whisper[827:20596] current task
      2015-11-19 10:36:23.261 Whisper[827:20596] 先加入队列
      2015-11-19 10:36:23.261 Whisper[827:20596] 次加入队列
      2015-11-19 10:36:23.261 Whisper[827:20596] next task
    • 自定义并发队列嵌套执行同步任务(不会产生死锁,程序正常运行)
    dispatch_queue_t conCurrentQueue = dispatch_queue_create("com.dullgrass.conCurrentQueue", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"current task");
    dispatch_sync(conCurrentQueue, ^{
         NSLog(@"先加入队列");
         dispatch_sync(conCurrentQueue, ^{
             NSLog(@"次加入队列");
         });
    });
    NSLog(@"next task");
    • 控制台输出如下:
      2015-11-19 10:39:21.301 Whisper[898:22273] current task
      2015-11-19 10:39:21.303 Whisper[898:22273] 先加入队列
      2015-11-19 10:39:21.303 Whisper[898:22273] 次加入队列
      2015-11-19 10:39:21.303 Whisper[898:22273] next task
    • 自定义并发队列执行异步任务
      dispatch_queue_t conCurrentQueue = dispatch_queue_create("com.dullgrass.conCurrentQueue", DISPATCH_QUEUE_CONCURRENT);
      NSLog(@"current task");
      dispatch_async(conCurrentQueue, ^{
         NSLog(@"先加入队列");
      });
      dispatch_async(conCurrentQueue, ^{
         NSLog(@"次加入队列");
      });
      NSLog(@"next task");
    • 控制台输出如下:
      2015-11-19 10:45:22.290 Whisper[1050:26445] current task
      2015-11-19 10:45:22.290 Whisper[1050:26445] next task
      2015-11-19 10:45:22.290 Whisper[1050:26505] 次加入队列
      2015-11-19 10:45:22.290 Whisper[1050:26500] 先加入队列

      异步执行任务,开启新的子线程,不影响当前线程任务的执行,并发队列中的任务,几乎是同步执行的,输出顺序不确定

Group queue (队列组)

当遇到需要执行多个线程并发执行,然后等多个线程都结束之后,再汇总执行结果时可以用group queue

  1. 使用场景: 同时下载多个图片,所有图片下载完成之后去更新UI(需要回到主线程)或者去处理其他任务(可以是其他线程队列)。
  2. 原理:使用函数dispatch_group_create创建dispatch group,然后使用函数dispatch_group_async来将要执行的block任务提交到一个dispatch queue。同时将他们添加到一个组,等要执行的block任务全部执行完成之后,使用dispatch_group_notify函数接收完成时的消息。
  3. 使用示例:

    dispatch_queue_t conCurrentGlobalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    dispatch_group_t groupQueue = dispatch_group_create();
    NSLog(@"current task");
    dispatch_group_async(groupQueue, conCurrentGlobalQueue, ^{
       NSLog(@"并行任务1");
    });
    dispatch_group_async(groupQueue, conCurrentGlobalQueue, ^{
       NSLog(@"并行任务2");
    });
    dispatch_group_notify(groupQueue, mainQueue, ^{
       NSLog(@"groupQueue中的任务 都执行完成,回到主线程更新UI");
    });
    NSLog(@"next task");
  4. 控制台输出:

    2015-11-19 13:47:55.117 Whisper[1645:97116] current task
    2015-11-19 13:47:55.117 Whisper[1645:97116] next task
    2015-11-19 13:47:55.119 Whisper[1645:97178] 并行任务1
    2015-11-19 13:47:55.119 Whisper[1645:97227] 并行任务2
    2015-11-19 13:47:55.171 Whisper[1645:97116] groupQueue中的任务 都执行完成,回到主线程更新UI
  5. 在当前线程阻塞的同步等待dispatch_group_wait

    dispatch_group_t groupQueue = dispatch_group_create();
    dispatch_time_t delayTime = dispatch_time(DISPATCH_TIME_NOW, 10 * NSEC_PER_SEC);
    dispatch_queue_t conCurrentGlobalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    NSLog(@"current task");
    dispatch_group_async(groupQueue, conCurrentGlobalQueue, ^{
    
       long isExecuteOver = dispatch_group_wait(groupQueue, delayTime);
       if (isExecuteOver) {
           NSLog(@"wait over");
       } else {
           NSLog(@"not over");
       }
       NSLog(@"并行任务1");
    });
    dispatch_group_async(groupQueue, conCurrentGlobalQueue, ^{
       NSLog(@"并行任务2");
    });

    控制台输出如下:

    2015-11-19 14:37:29.514 Whisper[2426:126683] current task
    2015-11-19 14:37:29.518 Whisper[2426:126791] 并行任务2
    2015-11-19 14:37:39.515 Whisper[2426:126733] wait over
    2015-11-19 14:37:39.516 Whisper[2426:126733] 并行任务1

    dispatch_time(dispatch_time_t when, int64_t delta);
    参数注释:
    第一个参数一般是DISPATCH_TIME_NOW,表示从现在开始
    第二个参数是延时的具体时间
    延时1秒可以写成如下几种:
    NSEC_PER_SEC----每秒有多少纳秒
    dispatch_time(DISPATCH_TIME_NOW, 1*NSEC_PER_SEC);
    USEC_PER_SEC----每秒有多少毫秒(注意是指在纳秒的基础上)
    dispatch_time(DISPATCH_TIME_NOW, 1000*USEC_PER_SEC); //SEC---毫秒
    NSEC_PER_USEC----每毫秒有多少纳秒。
    dispatch_time(DISPATCH_TIME_NOW, USEC_PER_SEC*NSEC_PER_USEC);SEC---纳秒

GCD中一些系统提供的常用dispatch方法

  1. dispatch_after延时添加到队列

    • 使用示例:
      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(@"3秒之后添加到队列");
      });
      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:22.654 Whisper[2725:172593] 3秒之后添加到队列

      dispatch_after只是延时提交block,并不是延时后立即执行,并不能做到精确控制,需要精确控制的朋友慎用哦

  2. dispatch_apply在给定的队列上多次执行某一任务,在主线程直接调用会阻塞主线程去执行block中的任务。

    • dispatch_apply函数的功能:把一项任务提交到队列中多次执行,队列可以是串行也可以是并行,dispatch_apply不会立刻返回,在执行完block中的任务后才会返回,是同步执行的函数。
    • dispatch_apply正确使用方法:为了不阻塞主线程,一般把dispatch_apply放在异步队列中调用,然后执行完成后通知主线程
    • 使用示例:
      dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);
      NSLog(@"current task");
      dispatch_async(globalQueue, ^{
      dispatch_queue_t applyQueue = dispatch_get_global_queue(0, 0);
      //第一个参数,3--block执行的次数
      //第二个参数,applyQueue--block任务提交到的队列
      //第三个参数,block--需要重复执行的任务
      dispatch_apply(3, applyQueue, ^(size_t index) {
            NSLog(@"current index %@",@(index));
            sleep(1);
      });
      NSLog(@"dispatch_apply 执行完成");
      dispatch_queue_t mainQueue = dispatch_get_main_queue();
      dispatch_async(mainQueue, ^{
            NSLog(@"回到主线程更新UI");
      });
      });
      NSLog(@"next task");
    • 控制台输出如下:
      2015-11-19 16:24:45.015 Whisper[4034:202269] current task
      2015-11-19 16:24:45.016 Whisper[4034:202269] next task
      2015-11-19 16:24:45.016 Whisper[4034:202347] current index 0
      2015-11-19 16:24:45.016 Whisper[4034:202344] current index 1
      2015-11-19 16:24:45.016 Whisper[4034:202345] current index 2
      2015-11-19 16:24:46.021 Whisper[4034:202347] dispatch_apply 执行完成
      2015-11-19 16:24:46.021 Whisper[4034:202269] 回到主线程更新UI
    • 嵌套使用dispatch_apply会导致死锁。
  1. dispatch_once保证在app运行期间,block中的代码只执行一次

    • 经典使用场景---单例
    • 单例对象ShareManager的定义:
     ShareManager的.h文件
    #import <Foundation/Foundation.h>
    @interface ShareManager : NSObject
    @property (nonatomic, copy) NSString *someProperty;
    + (ShareManager *)shareManager;
    + (ShareManager *)sharedManager;
    @end
    
    ShareManager的.m文件
    #import "ShareManager.h"
    @implementation ShareManager
    static ShareManager *sharedManager = nil;
    //GCD实现单例功能
    + (ShareManager *)shareManager
    {
     static dispatch_once_t onceToken;
     dispatch_once(&onceToken, ^{
         sharedManager = [[self alloc] init];
     });
     return sharedManager;
    }
    //在ARC下,非GCD,实现单例功能
    + (ShareManager *)sharedManager
    {
     @synchronized(self) {
         if (!sharedManager) {
             sharedManager = [[self alloc] init];
         }
     }
     return sharedManager;
    }
    - (instancetype)init{
     self = [super init];
     if (self) {
          _someProperty =@"Default Property Value";
     }
     return self;
    }
    @end
    
    ShareManager的使用
    #import "ShareManager.h"
    在需要使用的函数中,直接调用下面的方法
    ShareManager *share = [ShareManager sharedManager];
    NSLog(@"share is %@",share.someProperty);
  2. dispatch_barrier_async 栅栏的作用
    • 功能:是在并行队列中,等待在dispatch_barrier_async之前加入的队列全部执行完成之后(这些任务是并发执行的)再执行dispatch_barrier_async中的任务,dispatch_barrier_async中的任务执行完成之后,再去执行在dispatch_barrier_async之后加入到队列中的任务(这些任务是并发执行的)。
    • 使用示例:
      dispatch_queue_t conCurrentQueue = dispatch_queue_create("com.dullgrass.conCurrentQueue", DISPATCH_QUEUE_CONCURRENT);
      dispatch_async(conCurrentQueue, ^{
        NSLog(@"dispatch 1");
      });
      dispatch_async(conCurrentQueue, ^{
         NSLog(@"dispatch 2");
      });
      dispatch_barrier_async(conCurrentQueue, ^{
         NSLog(@"dispatch barrier");
      });
      dispatch_async(conCurrentQueue, ^{
         NSLog(@"dispatch 3");
      });
      dispatch_async(conCurrentQueue, ^{
         NSLog(@"dispatch 4");
      });
    • 控制台输出如下:
      2015-11-19 18:12:34.125 Whisper[22633:297257] dispatch 1
      2015-11-19 18:12:34.125 Whisper[22633:297258] dispatch 2
      2015-11-19 18:12:34.126 Whisper[22633:297258] dispatch barrier
      2015-11-19 18:12:34.127 Whisper[22633:297258] dispatch 3
      2015-11-19 18:12:34.127 Whisper[22633:297257] dispatch 4
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

IOS_多线程-GCD的基本使用

  • 2015年05月31日 07:50
  • 424B
  • 下载

iOS并发编程之GCD使用介绍

GCD的全称Grand Central Dispatch,是iOS开发中最常用的并发编程方式之一,今天我带领大家详细的领略一下GCD编程的强大之处。上一期,我们提到GCD是系统提供的一套C语言函数级别...

iOS多线程开发——GCD的使用与多线程开发浅析(二)

对于iOS多线程开发,我们时刻处于学习之中,在看书中,看文档中,项目开发中,都可以去提高自己。最近刚看完了《Objective-C高级编程 iOS与OS X多线程和内存管理》这本书后,对多线程有了更为...

iOS多线程编程之Grand Central Dispatch(GCD)介绍和使用

1、常用的方法dispatch_async 为了避免界面在处理耗时的操作时卡死,比如读取网络数据,IO,数据库读写等,我们会在另外一个线程中处理这些操作,然后通知主线程更新界面。 用GCD实现...

iOS多线程编程之Grand Central Dispatch(GCD)介绍和使用

介绍: Grand Central Dispatch 简称(GCD)是苹果公司开发的技术,以优化的应用程序支持多核心处理器和其他的对称多处理系统的系统。这建立在任务并行执行的线程池模式的基础...

iOS多线程开发——GCD的使用与多线程开发浅析

我在前面的博客中《GCD实践——串行队列/并发队列与IOS多线程详解》中对iOS中的同步异步、串行并行做了较为详细的讲解。在之后的几篇GCD实践的博客中对GCD的使用也有较为详细的实现。但是我们要注意...

关于iOS的GCD的介绍以及使用

1.简介  Grand Central Dispatch (GCD)是Apple开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式...

iOS多线程编程之GCD的使用

什么是线程呢?   1个CPU执行的CPU命令列为一条无分叉的路径即为线程。   这种无分叉路径不止1条,存在多条时即为多线程。   什么是GCD?   Grand Central Dispatch ...

iOS开发多线程篇—GCD的基本使用

iOS开发多线程篇—GCD的基本使用 一、主队列介绍 主队列:是和主线程相关联的队列,主队列是GCD自带的一种特殊的串行队列,放在主队列中得任务,都会放到主线程中执行。 提示:如果把...

ios 如何使用gcd

1。GCD之dispatch queue http://www.cnblogs.com/scorpiozj/archive/2011/07/25/2116459.html 2。iOS中GCD的...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:iOS中GCD的使用小结
举报原因:
原因补充:

(最多只允许输入30个字)