GCD使用经验与技巧浅谈--备

GCD(Grand Central Dispatch)可以说是Mac、iOS开发中的一大“利器”，本文就总结一些有关使用GCD的经验与技巧。

dispatch_once_t必须是全局或static变量

这一条算是“老生常谈”了，但我认为还是有必要强调一次，毕竟非全局或非static的dispatch_once_t变量在使用时会导致非常不好排查的bug，正确的如下：


1

2

3

4

5

//静态变量，保证只有一份实例，才能确保只执行一次

static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{

   //单例代码 

});

其实就是保证dispatch_once_t只有一份实例。

dispatch_queue_create的第二个参数

dispatch_queue_create，创建队列用的，它的参数只有两个，原型如下：


1

dispatch_queue_t dispatch_queue_create ( const char *label, dispatch_queue_attr_t attr );

在网上的大部分教程里（甚至Apple自己的文档里），都是这么创建串行队列的：


1

dispatch_queue_t queue = dispatch_queue_create("com.example.MyQueue", NULL);

看，第二个参数传的是“NULL”。 但是dispatch_queue_attr_t类型是有已经定义好的常量的，所以我认为，为了更加的清晰、严谨，最好如下创建队列：


1

2

3

4

//串行队列

dispatch_queue_t queue = dispatch_queue_create("com.example.MyQueue", DISPATCH_QUEUE_SERIAL);

//并行队列

dispatch_queue_t queue = dispatch_queue_create("com.example.MyQueue", DISPATCH_QUEUE_CONCURRENT);

常量就是为了使代码更加“易懂”，更加清晰，既然有，为啥不用呢~

dispatch_after是延迟提交，不是延迟运行

先看看官方文档的说明：


1

Enqueue a block for execution at the specified time.

Enqueue，就是入队，指的就是将一个Block在特定的延时以后，加入到指定的队列中，不是在特定的时间后立即运行！。

看看如下代码示例：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

//创建串行队列

dispatch_queue_t queue = dispatch_queue_create("me.tutuge.test.gcd", DISPATCH_QUEUE_CONCURRENT);

//立即打印一条信息        

NSLog(@"Begin add block...");        

//提交一个block

dispatch_async(queue, ^{

    //Sleep 10秒

    [NSThread sleepForTimeInterval:10];

    NSLog(@"First block done...");

});        

//5 秒以后提交block

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), queue, ^{

    NSLog(@"After...");

});

结果如下：


1

2

3

2015-03-31 20:57:27.122 GCDTest[45633:1812016] Begin add block...

2015-03-31 20:57:37.127 GCDTest[45633:1812041] First block done...

2015-03-31 20:57:37.127 GCDTest[45633:1812041] After...

从结果也验证了，dispatch_after只是延时提交block，并不是延时后立即执行。所以想用dispatch_after精确控制运行状态的朋友可要注意了~

正确创建dispatch_time_t

用dispatch_after的时候就会用到dispatch_time_t变量，但是如何创建合适的时间呢？答案就是用dispatch_time函数，其原型如下：


1

dispatch_time_t dispatch_time ( dispatch_time_t when, int64_t delta );

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

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

这里要特别注意的是，delta参数是“纳秒！”，就是说，延时1秒的话，delta应该是“1000000000”=。=，太长了，所以理所当然系统提供了常量，如下：


1

2

3

#define NSEC_PER_SEC 1000000000ull

#define USEC_PER_SEC 1000000ull

#define NSEC_PER_USEC 1000ull

关键词解释：

  • NSEC：纳秒。
  • USEC：微妙。
  • SEC：秒
  • PER：每

所以：

  1. NSEC_PER_SEC，每秒有多少纳秒。
  2. USEC_PER_SEC，每秒有多少毫秒。（注意是指在纳秒的基础上）
  3. NSEC_PER_USEC，每毫秒有多少纳秒。

所以，延时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毫秒之类的，也就不难了吧~

dispatch_suspend != 立即停止队列的运行

dispatch_suspend，dispatch_resume提供了“挂起、恢复”队列的功能，简单来说，就是可以暂停、恢复队列上的任务。但是这里的“挂起”，并不能保证可以立即停止队列上正在运行的block，看如下例子：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

dispatch_queue_t queue = dispatch_queue_create("me.tutuge.test.gcd", DISPATCH_QUEUE_SERIAL);

//提交第一个block，延时5秒打印。

dispatch_async(queue, ^{

    [NSThread sleepForTimeInterval:5];

    NSLog(@"After 5 seconds...");

});

//提交第二个block，也是延时5秒打印

dispatch_async(queue, ^{

    [NSThread sleepForTimeInterval:5];

    NSLog(@"After 5 seconds again...");

});

//延时一秒

NSLog(@"sleep 1 second...");

[NSThread sleepForTimeInterval:1];

//挂起队列                        

NSLog(@"suspend...");

dispatch_suspend(queue);

//延时10秒                

NSLog(@"sleep 10 second...");

[NSThread sleepForTimeInterval:10];

//恢复队列            

NSLog(@"resume...");

dispatch_resume(queue);

运行结果如下：


1

2

3

4

5

6

2015-04-01 00:32:09.903 GCDTest[47201:1883834] sleep 1 second...

2015-04-01 00:32:10.910 GCDTest[47201:1883834] suspend...

2015-04-01 00:32:10.910 GCDTest[47201:1883834] sleep 10 second...

2015-04-01 00:32:14.908 GCDTest[47201:1883856] After 5 seconds...

2015-04-01 00:32:20.911 GCDTest[47201:1883834] resume...

2015-04-01 00:32:25.912 GCDTest[47201:1883856] After 5 seconds again...

可知，在dispatch_suspend挂起队列后，第一个block还是在运行，并且正常输出。

结合文档，我们可以得知，dispatch_suspend并不会立即暂停正在运行的block，而是在当前block执行完成后，暂停后续的block执行。

所以下次想暂停正在队列上运行的block时，还是不要用dispatch_suspend了吧~

“同步”的dispatch_apply

dispatch_apply的作用是在一个队列（串行或并行）上“运行”多次block，其实就是简化了用循环去向队列依次添加block任务。但是我个人觉得这个函数就是个“坑”，先看看如下代码运行结果：


1

2

3

4

5

6

7

8

//创建异步串行队列

dispatch_queue_t queue = dispatch_queue_create("me.tutuge.test.gcd", DISPATCH_QUEUE_SERIAL);

//运行block3次

dispatch_apply(3, queue, ^(size_t i) {

    NSLog(@"apply loop: %zu", i);

});

//打印信息

NSLog(@"After apply");

运行的结果是：


1

2

3

4

2015-04-01 00:55:40.854 GCDTest[47402:1893289] apply loop: 0

2015-04-01 00:55:40.856 GCDTest[47402:1893289] apply loop: 1

2015-04-01 00:55:40.856 GCDTest[47402:1893289] apply loop: 2

2015-04-01 00:55:40.856 GCDTest[47402:1893289] After apply

看，明明是提交到异步的队列去运行，但是“After apply”居然在apply后打印，也就是说，dispatch_apply将外面的线程（main线程）“阻塞”了！

查看官方文档，dispatch_apply确实会“等待”其所有的循环运行完毕才往下执行=。=，看来要小心使用了。

避免死锁！

dispatch_sync导致的死锁

涉及到多线程的时候，不可避免的就会有“死锁”这个问题，在使用GCD时，往往一不小心，就可能造成死锁，看看下面的“死锁”例子：


1

2

3

4

//在main线程使用“同步”方法提交Block，必定会死锁。

dispatch_sync(dispatch_get_main_queue(), ^{

    NSLog(@"I am block...");

});

你可能会说，这么低级的错误，我怎么会犯，那么，看看下面的：


1

2

3

4

5

6

7

8

9

10

11

12

13

- (void)updateUI1 {

    dispatch_sync(dispatch_get_main_queue(), ^{

        NSLog(@"Update ui 1");

        

        //死锁！

        [self updateUI2];

    });

}

- (void)updateUI2 {

    dispatch_sync(dispatch_get_main_queue(), ^{

        NSLog(@"Update ui 2");

    });

}

在你不注意的时候，嵌套调用可能就会造成死锁！所以为了“世界和平”=。=，我们还是少用dispatch_sync吧。

dispatch_apply导致的死锁！

啥，dispatch_apply导致的死锁？。。。是的，前一节讲到，dispatch_apply会等循环执行完成，这不就差不多是阻塞了吗。看如下例子：


1

2

3

4

5

6

7

8

9

10

dispatch_queue_t queue = dispatch_queue_create("me.tutuge.test.gcd", DISPATCH_QUEUE_SERIAL);

       

dispatch_apply(3, queue, ^(size_t i) {

NSLog(@"apply loop: %zu", i);

   

    //再来一个dispatch_apply！死锁！      

dispatch_apply(3, queue, ^(size_t j) {

NSLog(@"apply loop inside %zu", j);

});

});

这端代码只会输出“apply loop: 1”。。。就没有然后了=。=

所以，一定要避免dispatch_apply的嵌套调用。

灵活使用dispatch_group

很多时候我们需要等待一系列任务（block）执行完成，然后再做一些收尾的工作。如果是有序的任务，可以分步骤完成的，直接使用串行队列就行。但是如果是一系列并行执行的任务呢？这个时候，就需要dispatch_group帮忙了~总的来说，dispatch_group的使用分如下几步：

  1. 创建dispatch_group_t
  2. 添加任务（block）
  3. 添加结束任务（如清理操作、通知UI等）

下面着重讲讲在后面两步。

添加任务

添加任务可以分为以下两种情况：

自己创建队列：使用dispatch_group_async。

无法直接使用队列变量（如使用AFNetworking添加异步任务）：使用dispatch_group_enter，dispatch_group_leave。

自己创建队列时，当然就用dispatch_group_async函数，简单有效，简单例子如下：


1

2

3

4

//省去创建group、queue代码。。。

dispatch_group_async(group, queue, ^{

    //Do you work...

});

当你无法直接使用队列变量时，就无法使用dispatch_group_async了，下面以使用AFNetworking时的情况：


1

2

3

4

5

6

7

8

9

10

11

12

13

AFHTTPRequestOperationManager *manager = [AFHTTPRequestOperationManager manager];

//Enter group

dispatch_group_enter(group);

[manager GET:@"http://www.baidu.com" parameters:nil success:^(AFHTTPRequestOperation *operation, id responseObject) {

    //Deal with result...

    //Leave group

    dispatch_group_leave(group);

}    failure:^(AFHTTPRequestOperation *operation, NSError *error) {

    //Deal with error...

    //Leave group

    dispatch_group_leave(group);

}];

//More request...

使用dispatch_group_enter，dispatch_group_leave就可以方便的将一系列网络请求“打包”起来~

添加结束任务

添加结束任务也可以分为两种情况，如下：

  1. 在当前线程阻塞的同步等待：dispatch_group_wait。
  2. 添加一个异步执行的任务作为结束任务：dispatch_group_notify

这两个比较简单，就不再贴代码了=。=

使用dispatch_barrier_async,dispatch_barrier_sync的注意事项

dispatch_barrier_async的作用就是向某个队列插入一个block，当目前正在执行的block运行完成后，阻塞这个block后面添加的block，只运行这个block直到完成，然后再继续后续的任务，有点“唯我独尊”的感觉=。=

值得注意的是：

dispatchbarrier\(a)sync只在自己创建的并发队列上有效，在全局(Global)并发队列、串行队列上，效果跟dispatch_(a)sync效果一样。

既然在串行队列上跟dispatch_(a)sync效果一样，那就要小心别死锁！

dispatch_set_context与dispatch_set_finalizer_f的配合使用

dispatch_set_context可以为队列添加上下文数据，但是因为GCD是C语言接口形式的，所以其context参数类型是“void *”。也就是说，我们创建context时有如下几种选择：

用C语言的malloc创建context数据。

用C++的new创建类对象。

用Objective-C的对象，但是要用__bridge等关键字转为Core Foundation对象。

以上所有创建context的方法都有一个必须的要求，就是都要释放内存！，无论是用free、delete还是CF的CFRelease，我们都要确保在队列不用的时候，释放context的内存，否则就会造成内存泄露。

所以，使用dispatch_set_context的时候，最好结合dispatch_set_finalizer_f使用，为队列设置“析构函数”，在这个函数里面释放内存，大致如下：


1

2

3

4

5

6

7

8

9

void cleanStaff(void *context) {

    //释放context的内存！

    //CFRelease(context);

    //free(context);

    //delete context;

}

...

//在队列创建后，设置其“析构函数”

dispatch_set_finalizer_f(queue, cleanStaff);

总结

其实本文更像是总结了GCD中的“坑”=。=

至于经验，总结一条，就是使用任何技术，都要研究透彻，否则后患无穷啊~

参考

时间： 2024-10-18 22:01:22

GCD使用经验与技巧浅谈--备的相关文章

GCD使用经验与技巧浅谈

前言 GCD(Grand Central Dispatch)可以说是Mac.iOS开发中的一大“利器”,本文就总结一些有关使用GCD的经验与技巧. dispatch_once_t必须是全局或static变量 这一条算是“老生常谈”了,但我认为还是有必要强调一次,毕竟非全局或非static的dispatch_once_t变量在使用时会导致非常不好排查的bug,正确的如下: 1 2 3 4 5 //静态变量,保证只有一份实例,才能确保只执行一次 static dispatch_once_t once

android App性能优化技巧浅谈

Android App性能优化,安卓App性能优化技巧,无论锤子还是茄子手机的不断冒出,Android系统的手机市场占有率目前来说还是最大的,因此基于Android开发的App数量也是很庞大的.那么,如何能开发出更高性能的Android App?相信是软件开发公司以及广大程序员们头疼的一大难题.今天,就给大家提供几个提高Android App性能的技巧. 高效地利用线程1.在后台取消一些线程中的动作 我们知道App运行过程中所有的操作都默认在主线程(UI线程)中进行的,这样App的响应速度就会受

浅谈数据库设计技巧(转)

说到数据库,我认为不能不先谈数据结构.1996年,在我初入大学学习计算机编程时,当时的老师就告诉我们说:计算机程序＝数据结构+算法.尽管现在的程序开发已由面向过程为主逐步过渡到面向对象为主,但我还是深深赞同8年前老师的告诉我们的公式:计算机程序＝数据结构+算法.面向对象的程序开发,要做的第一件事就是,先分析整个程序中需处理的数据,从中提取出抽象模板,以这个抽象模板设计类,再在其中逐步添加处理其数据的函数(即算法),最后,再给类中的数据成员和函数划分访问权限,从而实现封装. 数据库的最初雏形据说源

!! 浅谈Java学习方法和后期面试技巧

浅谈Java学习方法和后期面试技巧 昨天查看3303回复33 部落用户大酋长 下面简单列举一下大家学习java的一个系统知识点的一些介绍 一.java基础部分:java基础的时候,有些知识点是非常重要的,比如循环系列.For,while,do-while.这方面只要大家用心点基本没什么难点. 二.面向对象:oop面向对象的时候,偏重理论,相信这方面的文章也很多,大家可以多看看,在这就不说了.重点掌握面向对象的三大特征和基本原理. 三.java核心一:这方面主要偏重API,所以在学习了这章的时候,

转：浅谈关于b、h标签的优化技巧

<b>标签优化 <b>标签是一种加粗标记,作用就是加粗文章中的关键词,对于文章中重要的关键词加粗起到有利于用户阅读的作用.<b>标签的使用对于优化的作用是非常大的,我们不能忽视,下面我们来看一下,<b>标签的优化需要注意哪些事项,首先我们先对比一下显示效果差不多的<strong>(加重语气 产生字体加粗Bold的效果)和<h4>标签. <h4>.<strong>和<b>显示效果是一样的,他们都是普通

浅谈递归

定义 英文定义:Recursion is the process of repeating items in a self-similar way. 具体到计算机中去: 递归:又称为递回,在数学和计算机科学中,是指在函数的定义中使用函数自身的方法. [以上定义来源为wiki]. 英文的Recursion表达的是重复发生,再次重现的意思.而对应的中文翻译”递归”确表达了两个意思:” 递”+”归”.这两个意思,正是递归思想的精髓. 递归思想 递归的基本思想是:把规模大的问题转化为规模小的相似的子问题

【转】浅谈Nginx负载均衡与F5的区别

前言 笔者最近在负责某集团网站时,同时用到了Nginx与F5,如图所示,负载均衡器F5作为处理外界请求的第一道"墙",将请求分发到web服务器后,web服务器上的Nginx再进行处理,静态内容直接访问本地门户,动态数据则通过反向代理指向内网服务. 其实Nginx和F5这两者均可用作网站负载均衡,那二者有什么区别呢?笔者在此浅谈下Nginx与F5的一些区别. 目前很多网站或应用在设计之初都会为高并发的数据请求做负载均衡,不差钱的土豪用户一般会直接买F5硬件设备作为其负载均衡器,原因不用多

浅谈mysql主从复制的高可用解决方案

1.熟悉几个组件(部分摘自网络)1.1.drbd     —— DRBD(Distributed Replicated Block Device),DRBD号称是 "网络 RAID",开源软件,由 LINBIT 公司开发.DRBD 实际上是一种块设备的实现,主要被用于Linux平台下的高可用(HA)方案之中.他是有内核 模块和相关程序而组成,通过网络通信来同步镜像整个设备,有点类似于一个网络RAID的功能.也就是说当你将数据写入本地的DRBD设备上的文件系统 时, 数据会同时被发送到网

浅谈web应用的负载均衡、集群、高可用(HA)解决方案（转）

1.熟悉几个组件 1.1.apache     —— 它是Apache软件基金会的一个开放源代码的跨平台的网页服务器,属于老牌的web服务器了,支持基于Ip或者域名的虚拟主机,支持代理服务器,支持安 全Socket层(SSL)等等,目前互联网主要使用它做静态资源服务器,也可以做代理服务器转发请求(如:图片链等),结合tomcat等 servlet容器处理jsp.1.2.ngnix     —— 俄罗斯人开发的一个高性能的 HTTP和反向代理服务器.由于Nginx 超越 Apache 的高性能和稳