GCD

作者: Carson_Zhu | 来源:发表于2018-02-11 01:29 被阅读22次

简介

GCD是Apple开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并行任务。

GCD的优点

简单易用，效率高，速度快。
GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）。
程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码。

任务

就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。

同步执行sync
只能在当前线程中执行任务，不具备开启新线程的能力。
```
dispatch_sync(dispatch_queue_t  _Nonnull queue, ^(void)block)
```
异步执行async
可以在新的线程中执行任务，具备开启新线程的能力。
```
dispatch_async(dispatch_queue_t  _Nonnull queue, ^(void)block)
```

队列

这里的队列指任务队列，即用来存放任务的队列。队列是一种特殊的线性表，采用FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。

串行队列Serial Dispatch Queue
让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）。
并发队列Concurrent Dispatch Queue
可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）。

队列的使用

使用步骤

创建一个队列（串行队列或并发队列）。
将任务添加到队列中，然后系统就会根据任务类型执行任务（同步执行或异步执行）。

Main Queue

主线程串行队列，与主线程功能相同，提交至Main Queue的任务会在主线程中执行。

同步派发
```
dispatch_sync(dispatch_get_main_queue(), ^{
      NSLog(@"main queue sync");
});
```
当我们在主线程调用同步派发，首先会阻塞主线程，然后等待主线程执行完block，在回到主线程继续执行。如果主线程被阻塞，那么block永远无法返回，也就永远无法继续执行主线程了。

异步派发

NSLog(@"start");
dispatch_async(dispatch_get_main_queue(), ^{
      NSLog(@"main queue async");
});
NSLog(@"next");

打印结果:

2018-02-11 01:20:27.447395+0800 ThreadDemo[3385:344784] start
2018-02-11 01:20:27.447591+0800 ThreadDemo[3385:344784] next
2018-02-11 01:20:27.451263+0800 ThreadDemo[3385:344784] main queue async

解释:

异步派发不会阻塞当主线程，执行先将block放入queue中，然后再回到主线程继续执行，在其他队列刷新UI需要异步到主线程执行。

Global Queue

全局并发队列，全局并发队列由整个进程共享，有高、中（默认）、低、后台四个优先级别。

同步派发

NSLog(@"start");
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_sync(globalQueue, ^{
    NSLog(@"global queue sync");
});
NSLog(@"next");

打印结果:

2018-02-11 01:21:53.562723+0800 ThreadDemo[3414:347775] start
2018-02-11 01:21:53.562901+0800 ThreadDemo[3414:347775] global queue sync
2018-02-11 01:21:53.563014+0800 ThreadDemo[3414:347775] next

解释:

Global Queue中执行同步派发会阻塞主线程，等到Global Queue同步任务执行完才继续执行主线程任务。

异步派发

NSLog(@"start");
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(globalQueue, ^{
    NSLog(@"global queue async");
});
NSLog(@"next");

打印结果:

018-02-11 01:27:45.544458+0800 ThreadDemo[3488:357461] start
2018-02-11 01:27:45.544627+0800 ThreadDemo[3488:357461] next
2018-02-11 01:27:45.544645+0800 ThreadDemo[3488:357622] global queue async

解释:

Global Queue中执行异步派发不会阻塞主线程，任务同时进行。

Custom Queue

自定义队列，可以为串行，也可以为并发。

串行队列+同步派发

NSLog(@"start");
dispatch_queue_t serialQueue = dispatch_queue_create("com.carson.serialQueue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(serialQueue, ^{
    NSLog(@"serialQueue sync 1");
});
dispatch_sync(serialQueue, ^{
    NSLog(@"serialQueue sync 2");
});
NSLog(@"next");

打印结果:

2018-02-11 01:41:07.183833+0800 ThreadDemo[3619:377938] start
2018-02-11 01:41:07.183993+0800 ThreadDemo[3619:377938] serialQueue sync 1
2018-02-11 01:41:07.184087+0800 ThreadDemo[3619:377938] serialQueue sync 2
2018-02-11 01:41:07.184175+0800 ThreadDemo[3619:377938] next

解释:

串行队列中的任务按照先进先出的规则执行，同时只能有一个任务被执行。然而同步派发会阻塞主线程。

串行队列+异步派发

NSLog(@"start");
dispatch_queue_t serialQueue = dispatch_queue_create("com.carson.serialQueue", DISPATCH_QUEUE_SERIAL);
dispatch_async(serialQueue, ^{
    NSLog(@"serialQueue async 1");
});
dispatch_async(serialQueue, ^{
    NSLog(@"serialQueue async 2");
});
NSLog(@"next");

打印结果:

2018-02-11 01:47:56.663923+0800 ThreadDemo[3683:388060] start
2018-02-11 01:47:56.664115+0800 ThreadDemo[3683:388060] next
2018-02-11 01:47:56.664129+0800 ThreadDemo[3683:388144] serialQueue async 1
2018-02-11 01:47:56.664260+0800 ThreadDemo[3683:388144] serialQueue async 2

解释:

串行队列中的任务按照先进先出的规则执行，同时只能有一个任务被执行。然而异步派发不会阻塞主线程。

并发队列+同步派发

NSLog(@"start");
dispatch_queue_t concurrentQueue = dispatch_queue_create("com.carson.serialQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(concurrentQueue, ^{
    NSLog(@"concurrentQueue sync 1");
});
dispatch_sync(concurrentQueue, ^{
    NSLog(@"concurrentQueue sync 2");
});
NSLog(@"next");

打印结果:

2018-02-11 01:52:37.449783+0800 ThreadDemo[3750:396666] start
2018-02-11 01:52:37.450023+0800 ThreadDemo[3750:396666] concurrentQueue sync 1
2018-02-11 01:52:37.450131+0800 ThreadDemo[3750:396666] concurrentQueue sync 2
2018-02-11 01:52:37.450224+0800 ThreadDemo[3750:396666] next

解释:

并发队列中的任务同时执行，然而同步派发会阻塞主线程。

并发队列+异步派发

NSLog(@"start");
dispatch_queue_t concurrentQueue = dispatch_queue_create("com.carson.serialQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(concurrentQueue, ^{
    NSLog(@"concurrentQueue async 1");
});
dispatch_async(concurrentQueue, ^{
    NSLog(@"concurrentQueue async 2");
});
NSLog(@"next");

打印结果:

2018-02-11 01:57:30.663053+0800 ThreadDemo[3808:404776] start
2018-02-11 01:57:30.663260+0800 ThreadDemo[3808:404776] next
2018-02-11 01:57:30.663272+0800 ThreadDemo[3808:404873] concurrentQueue async 1
2018-02-11 01:57:30.663282+0800 ThreadDemo[3808:404874] concurrentQueue async 2

解释:

并发队列中的任务同时执行，然而异步派发不会阻塞主线程。

GCD的其他方法

GCD的栅栏方法

我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。

- (void)barrier {
    NSLog(@"start");
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_async(globalQueue, ^{
        NSLog(@"-----1-----");
    });
    dispatch_async(globalQueue, ^{
        NSLog(@"-----2-----");
    });
    dispatch_barrier_sync(globalQueue, ^{
        NSLog(@"-----barrier-----");
    });
    dispatch_async(globalQueue, ^{
        NSLog(@"-----3-----");
    });
    dispatch_async(globalQueue, ^{
        NSLog(@"-----4-----");
    });
    NSLog(@"next");
}

打印结果:

2018-02-11 02:14:43.214705+0800 ThreadDemo[4036:434350] start
2018-02-11 02:14:43.214936+0800 ThreadDemo[4036:434350] next
2018-02-11 02:14:43.214941+0800 ThreadDemo[4036:434484] -----1-----
2018-02-11 02:14:43.214952+0800 ThreadDemo[4036:434480] -----2-----
2018-02-11 02:14:43.214963+0800 ThreadDemo[4036:434483] -----barrier-----
2018-02-11 02:14:43.214971+0800 ThreadDemo[4036:434481] -----3-----
2018-02-11 02:14:43.214979+0800 ThreadDemo[4036:434482] -----4-----

GCD的延时执行方法

NSLog(@"start");
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0f * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
      // 3秒后异步执行这里的代码...
      NSLog(@"after...");
});
NSLog(@"next");

打印结果:

2018-02-11 02:21:11.246036+0800 ThreadDemo[4110:446397] start
2018-02-11 02:21:11.246257+0800 ThreadDemo[4110:446397] next
2018-02-11 02:21:14.530739+0800 ThreadDemo[4110:446397] after...

GCD的一次性代码

我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了GCD的dispatch_once方法。使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次。

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    // 只执行1次的代码(这里面默认是线程安全的)
});

GCD的快速迭代方法

通常我们会用for循环遍历，但是GCD给我们提供了快速迭代的方法dispatch_apply，使我们可以同时遍历。for循环的做法是每次取出一个元素，逐个遍历。dispatch_apply可以同时遍历多个数字。

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(6, globalQueue, ^(size_t index) {
    NSLog(@"%ld", index);
});

打印结果:

2018-02-11 02:27:17.311287+0800 ThreadDemo[4180:457101] 0
2018-02-11 02:27:17.311287+0800 ThreadDemo[4180:457186] 1
2018-02-11 02:27:17.311287+0800 ThreadDemo[4180:457189] 3
2018-02-11 02:27:17.311287+0800 ThreadDemo[4180:457198] 2
2018-02-11 02:27:17.311498+0800 ThreadDemo[4180:457189] 5
2018-02-11 02:27:17.311498+0800 ThreadDemo[4180:457186] 4

注意:
如果我们在串行队列中执行该方法，会发生死锁，所以第二个参数，千万不要传串行队列。

GCD的计时器

/**
 * GCD 计时器
 * dispatch Queue :决定了将来回调的方法在哪里执行。
 * dispatch_source_t timer  是一个OC对象
 * DISPATCH_TIME_NOW  第二个参数：定时器开始时间,也可以使用如下的方法:
 * dispatch_time(DISPATCH_TIME_NOW, 1.0 * NSEC_PER_SEC) 比当前时间晚1秒
 * intervalInSeconds  第三个参数: 定时器开始后的间隔时间（纳秒 NSEC_PER_SEC）
 * leewayInSeconds 第四个参数：间隔精准度，0代标最精准，传入一个大于0的数，代表多少秒的范围是可以接收的,主要为了提高程序性能，积攒一定的时间，Runloop执行完任务会睡觉，这个方法让他多睡一会，积攒时间，任务也就相应多了一点，而后一起执行
 */
__block int time = 0;
dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue());
dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC, .1 * NSEC_PER_SEC);
dispatch_source_set_event_handler(timer, ^{
    time ++;
    NSLog(@"%d", time);
    if (time >= 5) {
        // 这行代码必须执行，来销毁定时器
        dispatch_source_cancel(timer);
    }
});
dispatch_resume(timer);

打印结果:

2018-02-11 17:08:37.079367+0800 ThreadDemo[989:23128] 1
2018-02-11 17:08:38.076553+0800 ThreadDemo[989:23128] 2
2018-02-11 17:08:39.112748+0800 ThreadDemo[989:23128] 3
2018-02-11 17:08:40.076597+0800 ThreadDemo[989:23128] 4
2018-02-11 17:08:41.172450+0800 ThreadDemo[989:23128] 5

GCD的队列组

有时候我们会有这样的需求：分别异步执行2个耗时操作，然后当2个耗时操作都执行完毕后再回到主线程执行操作。这时候我们可以用到GCD的队列组。

方法一

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, globalQueue, ^{
    // 耗时的异步操作1
});
dispatch_group_async(group, globalQueue, ^{
    // 耗时的异步操作2
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    // 等前面的异步操作都执行完毕后，回到主线程...
});

方法二

dispatch_group_t group = dispatch_group_create();
dispatch_queue_t global = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
dispatch_group_enter(group);
dispatch_async(global, ^{
    NSLog(@"---1");
    dispatch_group_leave(group);
});
    
dispatch_group_enter(group);
dispatch_async(global, ^{
    NSLog(@"---2");
    dispatch_group_leave(group);
});
    
dispatch_group_notify(group, global, ^{
    NSLog(@"---notify");
});

GCD的信号量

信号量就是一种可用来控制访问资源的数量的标识，设定了一个信号量，在线程访问之前，加上信号量的处理，则可告知系统按照我们指定的信号量数量来执行多个线程。

//创建信号量，参数：信号量的初值，如果小于0则会返回NULL
dispatch_semaphore_create（信号量值）
 
//等待降低信号量
dispatch_semaphore_wait（信号量，等待时间）
 
//提高信号量
dispatch_semaphore_signal(信号量)

注意:
正常的使用顺序是先降低然后再提高，这两个函数通常成对使用。

dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
dispatch_queue_t global = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
dispatch_async(global, ^{
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"task 1");
    sleep(1);
    NSLog(@"complation task 1");
    dispatch_semaphore_signal(semaphore);
});
    
dispatch_async(global, ^{
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"task 2");
    sleep(1);
    NSLog(@"complation task 2");
    dispatch_semaphore_signal(semaphore);
});

2018-02-11 21:21:38.128868+0800 ThreadDemo[3189:354010] task 1
2018-02-11 21:21:39.130792+0800 ThreadDemo[3189:354010] complation task 1
2018-02-11 21:21:39.131156+0800 ThreadDemo[3189:354011] task 2
2018-02-11 21:21:40.136548+0800 ThreadDemo[3189:354011] complation task 2

解释:
设定信号值为1，线程一个一个执行，保证同一时间执行的线程数不超过1。

dispatch_semaphore_t semaphore = dispatch_semaphore_create(2);

2018-02-11 21:22:58.756510+0800 ThreadDemo[3215:356970] task 2
2018-02-11 21:22:58.756510+0800 ThreadDemo[3215:356971] task 1
2018-02-11 21:22:59.761933+0800 ThreadDemo[3215:356971] complation task 1
2018-02-11 21:22:59.761933+0800 ThreadDemo[3215:356970] complation task 2

解释:
设定信号值为2，先执行两个线程，等执行完，才会继续执行下两个，保证同一时间执行的线程数不超过2。

GCD

简介

GCD的优点

任务

队列

队列的使用

使用步骤

Main Queue

Global Queue

Custom Queue

GCD的其他方法

GCD的栅栏方法

GCD的延时执行方法

GCD的一次性代码

GCD的快速迭代方法

GCD的计时器

GCD的队列组

GCD的信号量

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读