多线程:GCD
多线程是程序开发中非常基础的一个概念,大家在开发过程中应该或多或少用过相关的东西。同时这恰恰又是一个比较棘手的概念,一切跟多线程挂钩的东西都会变得复杂。如果使用过程中对多线程不够熟悉,很可能会埋下一些难以预料的坑。
iOS中的多线程技术主要有NSThread, GCD和NSOperation。他们的封装层次依次递增,其中:
NSThread封装性最差,最偏向于底层,主要基于thread使用
GCD是基于C的API,直接使用比较方便,主要基于task使用
NSOperation是基于GCD封装的NSObject对象,对于复杂的多线程项目使用比较方便,主要基于队列使用
上篇文章介绍了NSThread的用法,NSThread已经属于古董级别的东西了,欣赏一下可以,真正使用就不要麻烦他了。GCD是多线程中的新贵,比起NSThread更加强大,也更容易使用。由于GCD的东西比较多,我会分好几篇文章介绍,这篇文章主要介绍GCD中的queue相关知识。
dispatch_queue_t
使用GCD之后,你可以不用再浪费精力去关注线程,GCD会帮你管理好一切。你只需要想清楚任务的执行方法(同步还是异步)和队列的运行方式(串行还是并行)即可。
任务是一个比较抽象的概念,表示一段用来执行的代码,他对应到代码里就是一个block或者一个函数。
队列分为串行队列和并行队列:
串行队列一次只能执行一个任务。只有一个任务执行完成之后,下一个任务才能执行,主线程就是一个串行的队列。
并行队列可以同时执行多个任务,系统会维护一个线程池来保证并行队列的执行。线程池会根据当前任务量自行安排线程的数量,以确保任务尽快执行。
队列对应到代码里是一个dispatch_queue_t对象:
1
|
dispatch_queue_t queue; |
对象就有内存。跟普通OC对象类似,我们可以用dispatch_retain()和dispatch_release()对其进行内存管理,当一个任务加入到一个queue中的时候,任务会retain这个queue,直到任务执行完成才会release。
值得高兴的是,iOS6之后,dispatch对象已经支持ARC,所以在ARC工程之下,我们可以不用担心他的内存,想怎么玩就怎么玩。
要申明一个dispatch的属性。一般情况下我们只需要用strong即可。
1
|
@property (nonatomic, strong) dispatch_queue_t queue; |
如果你是写一个framework,framework的使用者的SDK有可能还是古董级的iOS6之前。那么你需要根据OS_OBJECT_USE_OBJC做一个判断是使用strong还是assign。(一般github上的优秀第三方库都会这么做)
1
2
3
4
5
|
#if OS_OBJECT_USE_OBJC @property (nonatomic, strong) dispatch_queue_t queue; #else @property (nonatomic, assign) dispatch_queue_t queue; #endif |
async
GCD中有2个异步的API
1
2
|
void dispatch_async(dispatch_queue_t queue, dispatch_block_t block); void dispatch_async_f(dispatch_queue_t queue, void *context, dispatch_function_t work); |
他们都是将一个任务提交到queue中,提交之后立即返回,不等待任务的的执行。提交之后,系统会对queue做retain操作,任务执行完成之后,queue再被release。两个函数实际的功能是一样的,唯一的区别在于dispatch_async接受block作为参数,dispatch_async_f接受函数。
使用dispatch_async的时候block会被copy,在block执行完成之后block再release,由于是系统持有block,所以不用担心循环引用的问题,block里面的self不需要weak
在dispatch_async_f中,context会作为第一个参数传给work函数。如果work不需要参数,context可以传入NULL。work参数不能传入NULL,否则可能发生无法预料的事儿
异步是一个比较抽象的概念,简单的说就是将任务加入到队列中之后,立即返回,不需要等待任务的执行。语言的描述比较抽象,我们用代码加深一下对概念的理解
1
2
3
4
5
6
|
NSLog(@ "this is main queue, i want to throw a task to global queue" ); dispatch_queue_t globalQueue = dispatch_queue_create( "com.liancheng.global_queue" , DISPATCH_QUEUE_SERIAL); dispatch_async(globalQueue, ^{ // task }); NSLog(@ "this is main queue, throw task completed" ); |
上面这段代码,会以这样的方式运行,红色表示正在执行的模块,灰色表示未执行或者已经执行完成的模块。
先在main queue中执行第一个nslog
dispatch_async会将block提交到globalQueue中,提交成功之后立即返回
main queue执行第二个nslog
等global queue中block前面的任务执行完成之后,block被执行。
sync
与异步相似,GCD中同步的API也是2个
1
2
|
void dispatch_sync(dispatch_queue_t queue, dispatch_block_t block); void dispatch_sync_f(dispatch_queue_t queue, void *context, dispatch_function_t work); |
2个API作用相同:将任务提交到queue中,任务加入queue之后不会立即返回,等待任务执行完成之后再返回。同sync类似,dispatch_sync与dispatch_sync_f唯一的区别在于dispatch_sync接收block作为参数,block被系统持有,不需要对self使用weak。dispatch_sync_f接受函数work作为参数,context作为传给work函数的第一个参数。同样,work参数也不能传入NULL,否则会发生无法预料的事儿
同步表示任务加入到队列中之后不会立即返回,等待任务完成再返回。语言的描述比较抽象,我们再次用代码加深一下对概念的理解
1
2
3
4
5
6
|
NSLog(@ "this is main queue, i want to throw a task to global queue" ); dispatch_queue_t globalQueue = dispatch_queue_create( "com.liancheng.global_queue" , DISPATCH_QUEUE_SERIAL); dispatch_sync(globalQueue, ^{ // task }); NSLog(@ "this is main queue, throw task completed" ); |
我们来看看代码的运行方式:
先在main queue中执行第一个nslog
dispatch_sync会将block提交到global queue中,等待block的执行
global queue中block前面的任务执行完成之后,block执行
block执行完成之后,dispatch_sync返回
dispatch_sync之后的代码执行
由于dispatch_sync需要等待block被执行,这就非常容易发生死锁。如果一个串行队列,使用dispatch_sync提交block到自己队列中,就会发生死锁
1
2
3
4
5
6
7
8
9
|
dispatch_queue_t queue = dispatch_queue_create( "com.liancheng.serial_queue" , DISPATCH_QUEUE_SERIAL); dispatch_async(queue, ^{ // 到达串行队列 dispatch_sync(queue, ^{ //发生死锁 }); }); |
dispatch_sync的代码执行如图所示
dispatch_sync需要等待block执行完成,同时由于队列串行,block的执行需要等待前面的任务,也就是dispatch_sync执行完成。两者互相等待,永远也不会执行完成,死锁就这样发生了
从这里看发生死锁需要2个条件:
代码运行的当前队列是串行队列
使用sync将任务加入到自己队列中
如果queue是并行队列,或者将任务加入到其他队列中,这是不会发生死锁的。
获取队列
获取主线程队列
主线程是我们最常用的线程,GCD提供了非常简单的获取主线程队列的方法。
1
|
dispatch_queue_t dispatch_get_main_queue(void) |
方法不需要传入参数,直接返回主线程队列。
假设我们要在主线程更新UI:
1
2
3
|
dispatch_async(dispatch_get_main_queue(), ^{ [self updateUI]; }); |
执行加入到主线程队列的block,App会调用dispatch_main(), NSApplicationMain(),或者在主线程使用CFRunLoop。
获取全局队列
除了主线程队列,GCD提供了几个全局队列,可以直接获取使用
1
|
dispatch_queue_t dispatch_get_global_queue(long identifier, unsigned long flags); |
dispatch_get_global_queue方法获取的全局队列都是并行队列,并且队列不能被修改,也就是说对全局队列调用dispatch_suspend(), dispatch_resume(), dispatch_set_context()等方法无效
identifier: 用以标识队列优先级,推荐用qos_class枚举作为参数,也可以使用dispatch_queue_priority_t
flags: 预留字段,传入任何非0的值都可能导致返回NULL
可以看到dispatch_get_global_queue根据identifier参数返回相应的全局队列。identifier推荐使用qos_class枚举
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
__QOS_ENUM(qos_class, unsigned int, QOS_CLASS_USER_INTERACTIVE __QOS_CLASS_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0) = 0x21, QOS_CLASS_USER_INITIATED __QOS_CLASS_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0) = 0x19, QOS_CLASS_DEFAULT __QOS_CLASS_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0) = 0x15, QOS_CLASS_UTILITY __QOS_CLASS_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0) = 0x11, QOS_CLASS_BACKGROUND __QOS_CLASS_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0) = 0x09, QOS_CLASS_UNSPECIFIED __QOS_CLASS_AVAILABLE_STARTING(__MAC_10_10, __IPHONE_8_0) = 0x00, ); |
这个枚举与NSThread中的NSQualityOfService类似
QOS_CLASS_USER_INTERACTIVE: 最高优先级,交互级别。使用这个优先级会占用几乎所有的系统CUP和I/O带宽,仅限用于交互的UI操作,比如处理点击事件,绘制图像到屏幕上,动画等
QOS_CLASS_USER_INITIATED: 次高优先级,用于执行类似初始化等需要立即返回的事件
QOS_CLASS_DEFAULT: 默认优先级,当没有设置优先级的时候,线程默认优先级。一般情况下用的都是这个优先级
QOS_CLASS_UTILITY: 普通优先级,主要用于不需要立即返回的任务
QOS_CLASS_BACKGROUND: 后台优先级,用于用户几乎不感知的任务。
QOS_CLASS_UNSPECIFIED: 未知优先级,表示服务质量信息缺失
identifier除了使用qos_class枚举,也可以用dispatch_queue_priority_t作为参数。
1
2
3
4
5
6
|
#define DISPATCH_QUEUE_PRIORITY_HIGH 2 #define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 #define DISPATCH_QUEUE_PRIORITY_LOW (-2) #define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN typedef long dispatch_queue_priority_t; |
INT16_MINtypedef long dispatch_queue_priority_t;
dispatch_queue_priority_t对应到qos_class枚举有:
1
2
3
4
|
- DISPATCH_QUEUE_PRIORITY_HIGH: QOS_CLASS_USER_INITIATED - DISPATCH_QUEUE_PRIORITY_DEFAULT: QOS_CLASS_DEFAULT - DISPATCH_QUEUE_PRIORITY_LOW: QOS_CLASS_UTILITY - DISPATCH_QUEUE_PRIORITY_BACKGROUND: QOS_CLASS_BACKGROUND |
很多时候我们喜欢将0或者NULL传入作为参数
1
|
dispatch_get_global_queue(NULL, NULL) |
由于NULL等于0,也就是DISPATCH_QUEUE_PRIORITY_DEFAULT,所以返回的是默认优先级
创建队列
当无法获取到理想的队列时,我们可以自己创建队列。
1
|
dispatch_queue_t dispatch_queue_create(const char *label, dispatch_queue_attr_t attr); |
如果未使用ARC,dispatch_queue_create创建的queue在使用结束之后需要调用dispatch_release。
label: 队列的名称,调试的时候可以区分其他的队列
attr: 队列的属性,dispatch_queue_attr_t类型。用以标识队列串行,并行,以及优先级等信息
attr参数有三种传值方式:
1
2
3
4
5
6
7
8
9
10
|
// 串行 #define DISPATCH_QUEUE_SERIAL NULL // 并行 #define DISPATCH_QUEUE_CONCURRENT \ DISPATCH_GLOBAL_OBJECT(dispatch_queue_attr_t, \ _dispatch_queue_attr_concurrent) // 自定义属性值 dispatch_queue_attr_t dispatch_queue_attr_make_with_qos_class(dispatch_queue_attr_t attr, dispatch_qos_class_t qos_class, int relative_priority); |
DISPATCH_QUEUE_SERIAL或者NULL,表示创建串行队列,优先级为目标队列优先级。DISPATCH_QUEUE_CONCURRENT表示创建并行队列,优先级也为目标队列优先级。
dispatch_queue_attr_make_with_qos_class函数可以创建带有优先级的dispatch_queue_attr_t对象。通过这个对象可以自定义queue的优先级。
attr: 传入DISPATCH_QUEUE_SERIAL、NULL或者DISPATCH_QUEUE_CONCURRENT,表示串行或者并行
qos_class: 传入qos_class枚举,表示优先级级别
relative_priority: 相对于qos_class的相对优先级,qos_class用于区分大的优先级级别,relative_priority表示大级别下的小级别。relative_priority必须大于QOS_MIN_RELATIVE_PRIORITY小于0,否则将返回NULL。从GCD源码中可以查到QOS_MIN_RELATIVE_PRIORITY等于-15
使用dispatch_queue_attr_make_with_qos_class创建队列时,需要注意,非法的参数可能导致dispatch_queue_attr_make_with_qos_class返回NULL,dispatch_queue_create传入NULL会创建出串行队列。写代码过程中需要确保这是否是预期的结果
设置目标队列(2.25日更新,感谢@杨萧玉HIT 指出问题,原文章有误给大家致歉)
除了通过dispatch_queue_attr_make_with_qos_class设置队列的优先级之外,也可以使用设置目标队列的方法,设置队列的优先级。当队列创建时未设置优先级,队列将继承目标队列的优先级。(不过一般情况下还是推荐使用dispatch_queue_attr_make_with_qos_class设置队列的优先级)
1
|
void dispatch_set_target_queue(dispatch_object_t object, dispatch_queue_t queue); |
调用dispatch_set_target_queue会retain新目标队列queue,release原有目标队列。设置目标队列之后,block将会在目标队列中执行。注意:当目标队列串行时,任何在目标队列中执行的block都会串行执行,无论原队列是否串行。
假设有队列A、B是并行队列,C为串行队列。A,B的目标队列均设置为C,那么A、B、C中的block在设置目标队列之后最终都会串行执行。
例:队列1并行,队列2串行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
dispatch_queue_t queue1 = dispatch_queue_create( "com.company.queue1" , DISPATCH_QUEUE_CONCURRENT); dispatch_queue_t queue2 = dispatch_queue_create( "com.company.queue2" , DISPATCH_QUEUE_SERIAL); dispatch_async(queue1, ^{ // block1 for (int i = 0; i < 5; i ++) { NSLog(@ "+++++" ); } }); dispatch_async(queue1, ^{ // block2 for (int i = 0; i < 5; i ++) { NSLog(@ "=====" ); } }); dispatch_async(queue2, ^{ // block3 for (int i = 0; i < 5; i ++) { NSLog(@ "----" ); } }); |
运行一下可知block1,block2,block3并行执行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
2016-02-25 15:05:20.024 TGCD[1940:99120] +++++ 2016-02-25 15:05:20.024 TGCD[1940:99122] ===== 2016-02-25 15:05:20.024 TGCD[1940:99121] ---- 2016-02-25 15:05:20.025 TGCD[1940:99120] +++++ 2016-02-25 15:05:20.025 TGCD[1940:99121] ---- 2016-02-25 15:05:20.025 TGCD[1940:99122] ===== 2016-02-25 15:05:20.025 TGCD[1940:99120] +++++ 2016-02-25 15:05:20.025 TGCD[1940:99121] ---- 2016-02-25 15:05:20.025 TGCD[1940:99122] ===== 2016-02-25 15:05:20.025 TGCD[1940:99120] +++++ 2016-02-25 15:05:20.025 TGCD[1940:99121] ---- 2016-02-25 15:05:20.025 TGCD[1940:99122] ===== 2016-02-25 15:05:20.025 TGCD[1940:99120] +++++ 2016-02-25 15:05:20.025 TGCD[1940:99121] ---- 2016-02-25 15:05:20.025 TGCD[1940:99122] ===== |
如果将队列1的目标队列设置为队列2,会发生什么情况呢?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
dispatch_queue_t queue1 = dispatch_queue_create( "com.company.queue1" , DISPATCH_QUEUE_CONCURRENT); dispatch_queue_t queue2 = dispatch_queue_create( "com.company.queue2" , DISPATCH_QUEUE_SERIAL); dispatch_set_target_queue(queue1, queue2); dispatch_async(queue1, ^{ for (int i = 0; i < 5; i ++) { NSLog(@ "+++++" ); } }); dispatch_async(queue1, ^{ for (int i = 0; i < 5; i ++) { NSLog(@ "=====" ); } }); dispatch_async(queue2, ^{ for (int i = 0; i < 5; i ++) { NSLog(@ "----" ); } }); |
block1,block2,block3变为了串行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
2016-02-25 15:06:57.215 TGCD[1974:100675] +++++ 2016-02-25 15:06:57.215 TGCD[1974:100675] +++++ 2016-02-25 15:06:57.215 TGCD[1974:100675] +++++ 2016-02-25 15:06:57.215 TGCD[1974:100675] +++++ 2016-02-25 15:06:57.216 TGCD[1974:100675] +++++ 2016-02-25 15:06:57.216 TGCD[1974:100675] ===== 2016-02-25 15:06:57.216 TGCD[1974:100675] ===== 2016-02-25 15:06:57.216 TGCD[1974:100675] ===== 2016-02-25 15:06:57.216 TGCD[1974:100675] ===== 2016-02-25 15:06:57.216 TGCD[1974:100675] ===== 2016-02-25 15:06:57.216 TGCD[1974:100675] ---- 2016-02-25 15:06:57.216 TGCD[1974:100675] ---- 2016-02-25 15:06:57.216 TGCD[1974:100675] ---- 2016-02-25 15:06:57.217 TGCD[1974:100675] ---- 2016-02-25 15:06:57.217 TGCD[1974:100675] ---- |
注意不要循环设置目标队列,如A的目标队列为B,B的目标队列为A。这将会导致无法预知的错误
延时
GCD中有2个延时的API
1
2
|
dispatch_after(dispatch_time_t when, dispatch_queue_t queue, dispatch_block_t block); void dispatch_after_f(dispatch_time_t when, dispatch_queue_t queue, void *context, dispatch_function_t work); |
一定时间之后将block加入到queue中。when用于表示时间,如果传入DISPATCH_TIME_NOW会等同于dispatch_async。另外不允许传入DISPATCH_TIME_FOREVER,这会永远阻塞线程。
通前面其他方法类似。dispatch_after接收block作为参数,系统持有block,block中self不需要weak。dispatch_after_f接收work函数作为参数,context作为work函数的第一个参数
需要注意的是这里的延时是不精确的,因为加入队列不一定会立即执行。延时1s可能会1.5s甚至2s之后才会执行。
dispatch_barrier
在并行队列中,有的时候我们需要让某个任务单独执行,也就是他执行的时候不允许其他任务执行。这时候dispatch_barrier就派上了用场。
使用dispatch_barrier将任务加入到并行队列之后,任务会在前面任务全部执行完成之后执行,任务执行过程中,其他任务无法执行,直到barrier任务执行完成
dispatch_barrier在GCD中有4个API
1
2
3
4
|
void dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block); void dispatch_barrier_async_f(dispatch_queue_t queue, void *context, dispatch_function_t work); void dispatch_barrier_sync(dispatch_queue_t queue, dispatch_block_t block); void dispatch_barrier_sync_f(dispatch_queue_t queue, void *context, dispatch_function_t work); |
如果API在串行队列中调用,将等同于dispatch_async、dispatch_async_f、dispatch_sync、dispatch_sync_f,不会有任何影响。
dispatch_barrier最典型的使用场景是读写问题,NSMutableDictionary在多个线程中如果同时写入,或者一个线程写入一个线程读取,会发生无法预料的错误。但是他可以在多个线程中同时读取。如果多个线程同时使用同一个NSMutableDictionary。怎样才能保护NSMutableDictionary不发生意外呢?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
- (void)setObject:(id)anObject forKey:(id )aKey { dispatch_barrier_async(self.concurrentQueue, ^{ [self.mutableDictionary setObject:anObject forKey:aKey]; }); } - (id)objectForKey:(id)aKey { __block id object = nil; dispatch_sync(self.concurrentQueue, ^{ object = [self.mutableDictionary objectForKey:aKey]; }); return object; } |
当NSMutableDictionary写入的时候,我们使用dispatch_barrier_async,让其单独执行写入操作,不允许其他写入操作或者读取操作同时执行。当读取的时候,我们只需要直接使用dispatch_sync,让其正常读取即可。这样就可以保证写入时不被打扰,读取时可以多个线程同时进行
set_specific & get_specific
有时候我们需要将某些东西关联到队列上,比如我们想在某个队列上存一个东西,或者我们想区分2个队列。GCD提供了dispatch_queue_set_specific方法,通过key,将context关联到queue上
1
|
void dispatch_queue_set_specific(dispatch_queue_t queue, const void *key, void *context, dispatch_function_t destructor); |
queue:需要关联的queue,不允许传入NULL
key:唯一的关键字
context:要关联的内容,可以为NULL
destructor:释放context的函数,当新的context被设置时,destructor会被调用
有存就有取,将context关联到queue上之后,可以通过dispatch_queue_get_specific或者dispatch_get_specific方法将值取出来。
1
2
|
void *dispatch_queue_get_specific(dispatch_queue_t queue, const void *key); void *dispatch_get_specific(const void *key); |
dispatch_queue_get_specific: 根据queue和key取出context,queue参数不能传入全局队列
dispatch_get_specific: 根据唯一的key取出当前queue的context。如果当前queue没有key对应的context,则去queue的target queue取,取不着返回NULL,如果对全局队列取,也会返回NULL
iOS 6之后dispatch_get_current_queue()被废弃(废弃的原因这里不多解释,如果想了解可以看这里),如果我们需要区分不同的queue,可以使用set_specific方法。根据对应的key是否有值来区分
原文链接:http://www.cocoachina.com/ios/20160225/15422.html
多线程:GCD的更多相关文章
- iOS 多线程GCD的基本使用
<iOS多线程简介>中提到:GCD中有2个核心概念:1.任务(执行什么操作)2.队列(用来存放任务) 那么多线程GCD的基本使用有哪些呢? 可以分以下多种情况: 1.异步函数 + 并发队列 ...
- iOS多线程 GCD
iOS多线程 GCD Grand Central Dispatch (GCD)是Apple开发的一个多核编程的解决方法. dispatch queue分成以下三种: 1)运行在主线程的Main que ...
- 修改版: 小伙,多线程(GCD)看我就够了,骗你没好处!
多线程(英语:multithreading),是指从软件或者硬件上实现多个线程并发执行的技术.具有多线程能力的计算机因有硬件支持而能够在同一时间执行多于一个线程,进而提升整体处理性能.具有这种能力的系 ...
- ios多线程-GCD基本用法
ios中多线程有三种,NSTread, NSOperation,GCD 这篇就讲讲GCD的基本用法 平时比较多使用和看到的是: dispatch_async(dispatch_get_global_q ...
- iOS 多线程GCD简介
一.简介 1.1 GCD (Grand Central Dispatch )是Apple开发的一个多核编程的解决方法. Grand 含义是“伟大的.宏大的”,Central含义“中央的”,Dispat ...
- 多线程GCD的基本使用以及注意点
GCD的使用 一:队列 1.串行队列:添加到队列中的任务是一个一个执行的 2.并行(发)队列:添加到队列中的任务是多个同时执行的(一个队列中的多个任务可以同时执行) 3.主队列:里 ...
- IOS开发之多线程 -- GCD的方方面面
前言:这篇GCD的博文是本人阅读了很多海内外大神的关于GCD的文章,以及结合之前自己对GCD的粗浅的认识,然后取其精华,去其槽粕,综合起来的笔记,而且是尽可能的以通熟易懂的并且是正确的理论论述方式呈现 ...
- 刀哥多线程GCD核心概念gcd
GCD GCD 核心概念 将任务添加到队列,并且指定执行任务的函数 任务使用 block 封装 任务的 block 没有参数也没有返回值 执行任务的函数 异步 dispatch_async 不用等待当 ...
- ios开发多线程--GCD
引言 虽然GCD使用很广,而且在面试时也经常问与GCD相关的问题,但是我相信深入理解关于GCD知识的人肯定不多,大部分都是人云亦云,只是使用过GCD完成一些很简单的功能.当然,使用GCD完成一些简单的 ...
- 多线程GCD
经常使用:规避很多线程相关的复杂的逻辑 为什么会gcd?因为pthread和nsthread要求开发人员对线程相关的知识了解深入; 手动启动线程:加锁/解锁;造成很多隐患 --> 苹果公司给出了 ...
随机推荐
- Emacs及扩展配置
Emacs及扩展配置 Table of Contents 1. 动机之反思 2. 它山之石 3. 扩展的管理 4. 我额外安装的通用扩展(在purcell基础上) 5. LaTex相关的问题和配置 6 ...
- C语言源字符集与执行字符集
参考: http://blog.csdn.net/yucan1001/article/details/7188267 http://blog.csdn.net/dbzhang800/article ...
- Chrome 强制刷新缓存的方法
https://jingyan.baidu.com/article/11c17a2c2a9e27f446e39d98.html
- Java 设计模式系列(八)装饰者模式
Java 设计模式系列(八)装饰者模式 装饰模式又名包装(Wrapper)模式.装饰模式以对客户端透明的方式扩展对象的功能,是继承关系的一个替代方案.Decorator 或 Wrapper 一.装饰模 ...
- JVM 垃圾回收- 转载 知识碎片
最近关注了一下垃圾回收的问题,想了解一下JVM 关于方法区的垃圾回收机制,找了几篇文章,不同的文章从不同角度讲述了一下,嗯... 拼凑起来 记录一下, 有些未验证正确性... JVM 方法区 当JVM ...
- 让Asp.Net WebAPI支持OData查询,排序,过滤。(转)
出处:http://www.cnblogs.com/liuzhendong/p/4233380.html 让Asp.Net WebAPI支持OData后,就能支持在url中直接输入排序,过滤条件了. ...
- PHP(九)数组(2)
- [label][WorldPress] 一个很方便查找定位WorldPress源代码位置的网址
作为 WordPress 的新手,根本不熟悉那些函数究竟是什么作用的,所以就必须要去看源代码. 要去查看源代码,那么你就必须要熟悉 WordPress 下面文件的作用,以及那个文件中定义了有哪些函数? ...
- mybatis 教程
地址: http://blog.csdn.net/techbirds_bao/article/details/9233599/
- XML--将XML中数据提取出转换成表
DECLARE @xml XMLSET @xml='<Students> <Student id="1001"> <name&g ...