GCD

2018-02-11  本文已影响22人  Carson_Zhu

简介

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

GCD的优点

任务

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

队列

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

队列的使用

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

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

Global Queue

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

Custom Queue

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

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。

上一篇下一篇

猜你喜欢

热点阅读