多线程：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");

上面这段代码，会以这样的方式运行，红色表示正在执行的模块，灰色表示未执行或者已经执行完成的模块。

  1. 先在main queue中执行第一个nslog
  2. dispatch_async会将block提交到globalQueue中，提交成功之后立即返回
  3. main queue执行第二个nslog
  4. 等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");

我们来看看代码的运行方式：

  1. 先在main queue中执行第一个nslog
  2. dispatch_sync会将block提交到global queue中，等待block的执行
  3. global queue中block前面的任务执行完成之后，block执行
  4. block执行完成之后，dispatch_sync返回
  5. 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个条件：

  1. 代码运行的当前队列是串行队列
  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

时间： 2024-10-17 03:41:17

多线程：GCD的相关文章

iOS多线程 GCD

iOS多线程 GCD Grand Central Dispatch (GCD)是Apple开发的一个多核编程的解决方法. dispatch queue分成以下三种: 1)运行在主线程的Main queue,通过dispatch_get_main_queue获取. /*! * @function dispatch_get_main_queue * * @abstract * Returns the default queue that is bound to the main thread. *

多线程 GCD

n多线程 GCD n简介 n什么是GCD p全称是Grand Central Dispatch,可译为“牛逼的中枢调度器” p纯C语言,提供了非常多强大的函数 p nGCD的优势 pGCD是苹果公司为多核的并行运算提出的解决方案 pGCD会自动利用更多的CPU内核(比如双核.四核) pGCD会自动管理线程的生命周期(创建线程.调度任务.销毁线程) p程序员只需要告诉GCD想要执行什么任务,不需要编写任何线程管理代码 n任务和队列 nGCD中有2个核心概念 p任务:执行什么操作 p队列:用来存放任

iOS多线程GCD

Grand Central Dispatch (GCD)是Apple开发的一个多核编程的解决方法. dispatch queue分成以下三种: 1)运行在主线程的Main queue,通过dispatch_get_main_queue获取. /*! * @function dispatch_get_main_queue * * @abstract * Returns the default queue that is bound to the main thread. * * @discussi

IOS 多线程GCD的使用[转载于新浪微博， 原作者：太阳石]

原文 在红黑联盟上看到一篇关于多线程GCD的教程文章,写的深入浅出,特转载于此,以备不时之需.原文链接另:补充两个GCD代码,都是Xcode snippet里面提供的:1.Dispatch After主要用于延迟执行一些代码.例子: int64_t delayInSeconds = 1.0; dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC); dispatch_aft

【iOS】多线程GCD

GCD(Grand Central Dispatch) : 牛逼的中枢调度器.苹果自带,纯C语言实现,提供了非常多且强大的函数,它可以提高代码的执行效率与多核的利用率. 一.GCD的基本使用 1.GCD中的两个核心概念: ?任务: 执行什么任务. ?队列: 用来存放任务. (用来调度任务) 2.GCD使用的2个步骤: ?1.定制任务. (确定想做的事情) ?2.将任务添加到队列中. ?GCD会自动将队列中的任务取出, 放到对应的线程中执行. ?遵循队列的FIFO原则: 先进先出. 3.同步和异步

iOS开发之多线程——GCD介绍

iOS开发之多线程——GCD的介绍 一.简单介绍 1.GCD ( Grand Central Dispatch) 可以翻译为“中枢调度器”.纯C语言,并且提供了非常强大的函数. 2.GCD 有什么优势: GCD是苹果公司为多核的并行运算提出的解决方案 GCD会自动利用更多地CPU 内核 (比如双核.四核) GCD会自动管理线程的生命周期 (创建线程.调度任务.销毁线程) 程序猿只需要告诉GCD想要执行设呢任务,不需要编写任何线程管理代码. 二.任务和队列 GCD中有两个核心概念 (1)任务: 执

深入IOS多线程 GCD(一)

一,什么是GCD GCD是异步执行任务的技术之一,一般将应用程序中记述的线程管理用的代码在系统级中实现.开发者只需要定义想执行的任务并追加到适当的dispatch queue中,GCD就能生成必要的线程并计划执行任务.由于线程管理师作为系统的一部分来实现的,因此可统一管理,也可执行任务,这样就比以前的线程更有效率. 也就是说GCD用我们难以置信的非常简单的记述方法,实现了极为复杂的多线程编程,可以说这是一项划时代的技术.下面是使用了GCD源码的例子,虽然稍微抽象,但从中也能感受到GCD的威力 d

iOS 多线程GCD的基本使用

<iOS多线程简介>中提到:GCD中有2个核心概念:1.任务(执行什么操作)2.队列(用来存放任务) 那么多线程GCD的基本使用有哪些呢? 可以分以下多种情况: 1.异步函数 + 并发队列 /** * 异步函数 + 并发队列:可以同时开启多条线程 */ - (void)asyncConcurrent { // 1.创建一个并发队列 // dispatch_queue_create(const char *label, dispatch_queue_attr_t attr); // label

iOS多线程——GCD篇

什么是GCD GCD是苹果对多线程编程做的一套新的抽象基于C语言层的API,结合Block简化了多线程的操作,使得我们对线程操作能够更加的安全高效. 在GCD出现之前Cocoa框架提供了NSObject类的 performSelectorInBackground:withObject performSelectorOnMainThread 方法来简化多线程编程技术. GCD可以解决以下多线程编程中经常出现的问题:1.数据竞争(比如同时更新一个内存地址) 2.死锁(互相等待) 3.太多线程导致消耗

IOS 多线程/GCD

多线程  -单利 + (SingleHandel *)shareModel { static dispatch_once_t onceQueue; dispatch_once(&onceQueue, ^{ shareSingle = [[SingleHandel alloc] init]; }); return shareSingle; } /* //第一种线程开启方式 NSThread *thread1 = [[NSThread alloc] initWithTarget:self selec