《Objective-C高级编程》 Grand Central Dispatch

《Objective-C高级编程：iOS与OS X多线程和内存管理》

3.1 Grand Central Dispatch（GCD）概要

3.1.1 什么是CGD

Grand Central dispatch(GCD)是异步执行任务的技术之一。一般将应用程序中记述的线程管理用的代码在系统级中实现。开发者只需要定义想执行的任务并追加到适当的dispatch Queue中，GCD就能生成必要的线程并计划执行任务。由于线程管理是作为系统的一部分来实现的，因此可以统一管理，也可执行任务，这样就比以前的线程更加有效率。

也就是说，GCD使用简洁的记述方法，实现了复杂繁琐的多线程编程🌰：

 dispatch_async(queue, ^{
     // 执行长时间网络处理
     dispatch_async(dispatch_get_main_queue(), ^{
          //只在主线程可以执行的处理
         // 主界面做的事，例如用户刷新
     });
 });

等同于NSObject类的performSelectorInBackground实例方法和performSelectorOnMainThread实例方法：

- (void)launchThreadByNSObject_performSelectorInBackground_withObject
{
     // 执行长时间网络处理
    [self performSelectorInBackground:@selector(dowork) withObject:nil];
}
- (void)dowork
{
    [self performSelectorOnMainThread:@selector(donework) withObject:nil waitUntilDone:NO];
}
- (void)donework
{
    //只在主线程可以执行的处理
    // 主界面做的事，例如用户刷新
}

由上可知，使用CGD，通过 GCD 提供的系统级线程管理提高执行效率。

3.1.2 多线程编程

  • 线程（thread）是操作系统能够进行运算调度的最小单位。

Mac、iPhone的操作系统OS X、iOS根据用户的指示启动应用程序后，首先便将包含在应用程序中的CPU命令列配置到内存中。CPU从应用程序指定的地址开始，一个一个地执行CPU命令列。由于一个CPU一次只能执行一个命令，不能执行某处分开的并列的两个命令，因此通过CPU执行的CPU命令列就是一条无分叉的路。这里所说的“1个CPU执行的CPU名列为一条无分叉的路”就是“线程”。

图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》

  • 现在一个物理的CPU芯片实际上有64（64核）个CPU，即可以拥有多条线程。


    图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》

  • 在iOS开发中，一共有四种多线程技术：pthread，NSThread，GCD，NSOperation：

    • pthread ，NSThread是面向线程开发的多线程技术，需要开发者自己去维护线程的生命周期，比较繁琐。

  • GCD， NSOperation是面向队列开发的多线程技术，开发者仅仅定义想执行的任务追加到适当的Dispatch Queue（队列）中并设置一些优先级，依赖等操作就可以了，其他的事情可以交给系统来做。

  • 多线程编程会产生很多编程技术问题：数据竞争、死锁、内存消耗等问题。


    图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》

  • 尽管多线程编程极易发生各种问题，但是使用多线程编程可保证应用程序的响应性能。


    图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》

多线程编程的优缺点：

  • 优点:适当提高程序的执行效率；适当提高资源利用率(CPU/内存利用率)；
  • 缺点:开启线程需要占用一定的内存空间(默认情况下，主线程占用1M，子线程占用512KB)，如果开启大量的线程，会占用大量的内存空间，降低程序的性能；
#注意#：
 1. 不要同时开太多线程(1~3条线程即可，不要超过5条);

 2. 线程概念：
   - 主线程：UI线程，显示、刷新UI界面，处理UI控件事件；
  - 子线程：后台线程，异步线程；

 3 .不要把耗时操作放在主线程，要放在子线程中执行
  • 想要更加了解线程、进程等可自行参阅《操作系统原理》这本书。

3.2 GCD的API

3.2.1 Dispatch Queue

“开发者要做的只是定义想执行的任务并追加到适当的Dispatch Queue中”。

用源码表示如下：

dispatch_async(queue, ^{
    /*
     * 想执行的任务
     */
});

该源码用block的语法定义想执行的任务然后通过dispatch_async函数讲任务追加到赋值在变量queue的"Dispatch Queue"中。

Dispatch Queue是什么呢？
  • Dispatch Queue是执行处理的等待队列, 按照先进先出(FIFO, First-In-First-Out)的顺序进行任务处理.
图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》
  • Dispatch Queue队列分两种, 一种是串行队列(Serial Dispatch Queue), 一种是并行队列(Concurrent Dispatch Queue)。
图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》

图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》
  • Serial dispatch Queue是等待执行完成后才开始下一个处理。
    // 创建一个Serial dispatch Queue
    dispatch_queue_t serialdispatchQueue =dispatch_queue_create("com.Sky.serialTest", DISPATCH_QUEUE_SERIAL);
    dispatch_async(serialdispatchQueue, ^{NSLog(@"serialdispatchQueue  %@", [NSThread currentThread]);});
    dispatch_async(serialdispatchQueue, ^{NSLog(@"serialdispatchQueue  %@", [NSThread currentThread]);});
    dispatch_async(serialdispatchQueue, ^{NSLog(@"serialdispatchQueue  %@", [NSThread currentThread]);});
    dispatch_async(serialdispatchQueue, ^{NSLog(@"serialdispatchQueue  %@", [NSThread currentThread]);});

执行结果如下:

serialdispatchQueue  <NSThread: 0x600000675700>{number = 3, name = (null)}
serialdispatchQueue  <NSThread: 0x60800087ef00>{number = 3, name = (null)}
serialdispatchQueue  <NSThread: 0x60000126e4c0>{number =3, name = (null)}
serialdispatchQueue  <NSThread: 0x60800087ef80>{number =3, name = (null)}
  • Concurrent dispatch Queue是不等待执行，那么任何任务添加到Concurrent dispatch Queue后，就会立即执行。Concurrent dispatch Queue并行执行的处理的数量取决于当前系统的状态。
     // 创建一个Concurrent dispatch Queue
    dispatch_queue_t concurrentdispatchQueue = dispatch_queue_create("com.Sky.serialTest", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(concurrentdispatchQueue, ^{NSLog(@"concurrentdispatchQueue  %@", [NSThread currentThread]);});
    dispatch_async(concurrentdispatchQueue, ^{NSLog(@"concurrentdispatchQueue  %@", [NSThread currentThread]);});
    dispatch_async(concurrentdispatchQueue, ^{NSLog(@"concurrentdispatchQueue  %@", [NSThread currentThread]);});
    dispatch_async(concurrentdispatchQueue, ^{NSLog(@"concurrentdispatchQueue  %@", [NSThread currentThread]);});

执行结果如下:

concurrentdispatchQueue  <NSThread: 0x600000675700>{number = 3, name = (null)}
concurrentdispatchQueue  <NSThread: 0x60800087ef00>{number = 5, name = (null)}
concurrentdispatchQueue  <NSThread: 0x60000126e4c0>{number = 6, name = (null)}
concurrentdispatchQueue  <NSThread: 0x60800087ef80>{number =4, name = (null)}
图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》

3.2.1 dispatch_queue_create

在Dispatch Queue中，我们使用了dispatch_queue_create来建立一个Queue。
生成Dispatch Queue有两种方法：
  • 通过GCD的API生成dispatch Queue
  • 获取系统标准提供的dispatch Queue
使用GCD的API生成dispatch_queue_create:
  // 创建一个Concurrent dispatch Queue
    dispatch_queue_t concurrentdispatchQueue = dispatch_queue_create("com.Sky.serialTest", DISPATCH_QUEUE_CONCURRENT);

    // 创建一个Serial dispatch Queue
    dispatch_queue_t serialdispatchQueue = dispatch_queue_create("com.Sky.serialTest", DISPATCH_QUEUE_SERIAL);
其中，dispatch_queue_create函数有2个参数:
  • 第一个参数是dispatch Queue的名称。该名称在Xcode和Instruments的调试器中作为dispatch Queue的名称表示。
  • 第二个参数是指定dispatch Queue的类型，DISPATCH_QUEUE_CONCURRENT 和DISPATCH_QUEUE_SERIAL。如果填写NULL则默认为DISPATCH_QUEUE_SERIAL。

多个Serial dispatch Queue可并行执行！

    // 创建一个SerialQueue
    dispatch_queue_t serialdispatchQueue1 = dispatch_queue_create("com.Sky.serialTest", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t serialdispatchQueue2 = dispatch_queue_create("com.Sky.serialTest", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t serialdispatchQueue3 = dispatch_queue_create("com.Sky.serialTest", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t serialdispatchQueue4 = dispatch_queue_create("com.Sky.serialTest", DISPATCH_QUEUE_SERIAL);
    dispatch_async(serialdispatchQueue1, ^{NSLog(@"serialdispatchQueue1  %@", [NSThread currentThread]);});
    dispatch_async(serialdispatchQueue2, ^{NSLog(@"serialdispatchQueue2  %@", [NSThread currentThread]);});
    dispatch_async(serialdispatchQueue3, ^{NSLog(@"serialdispatchQueue3  %@", [NSThread currentThread]);});
    dispatch_async(serialdispatchQueue4, ^{NSLog(@"serialdispatchQueue4  %@", [NSThread currentThread]);});

执行结果如下：

serialdispatchQueue1  <NSThread: 0x600000675700>{number = 3, name = (null)}
serialdispatchQueue3  <NSThread: 0x60800087ef00>{number = 5, name = (null)}
serialdispatchQueue4  <NSThread: 0x60000126e4c0>{number = 6, name = (null)}
serialdispatchQueue2  <NSThread: 0x60800087ef80>{number =4, name = (null)}
图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》
dispatch_queue_create使用时应注意：

  • 不能无限制的创建Serial Dispatch Queue,会消耗大量的内存，引起大量的上下文切换，大幅度降低系统的响应性能。


    图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》

  • 在为了避免多个线程对同一个资源进行操作时(数据竞争)使用Serial Dispatch Queue，因为其使用一个线程，数据安全。


    图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》
  • 当不需要顾忌数据竞争问题时候，推荐使用Concurrent Dispatch Queue。因为不管生成多少，系统会对其进行管理，不用担心Serial Dispatch Queue类似的问题。

  • 最好为每一个Dispatch Queue编写不同的名字，否则你会在调试多线程程序的时候会后悔没有为Dispatch Queue署名。

  • 关于 dispatch_retain和dispatch_release 的使用

  • 如果你部署的最低目标低于 iOS 6.0 or Mac OS X 10.8，你应该自己管理GCD对象,使用
    (dispatch_retain,dispatch_release),ARC并不会去管理它们。

  • 如果你部署的最低目标是 iOS 6.0 or Mac OS X 10.8或者更高，ARC已经能够管理GCD对象了,这时候,GCD对象就如同普通的OC对象一样,不应该使用dispatch_retain或者dispatch_release。

3.2.3 Main Dispatch Queue/Global Dispatch Queue

生成Dispatch Queue的另一种方法：

通过系统标准提供的Dispatch Queue：Main Dispatch Queue、Global Dispatch Queue.
  • Main Dispatch Queue,即主线程中执行的Dispatch Queue，而主线程只有一个，所以Main Dispatch Queue就是Serial Dispatch Queue.
    图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》
/** Main Dispatch Queue的获取 */
dispatch_queue_t mainDispatchQueue = dispatch_get_main_queue();
  • Global Dispatch Queue,是所有应用程序都能够使用的Concurrent Dispatch Queue。所以没有必要通过dispatch_queue_create来创建，直接获取Global Dispatch Queue即可。
/** Global Dispatch Queue（最高）的获取方法 */
dispatch_queue_t highGlobalDispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);

/** Global Dispatch Queue（默认）的获取方法 */
dispatch_queue_t defaultGlobalDispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

/** Global Dispatch Queue（低）的获取方法 */
dispatch_queue_t losGlobalDispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);

/** Global Dispatch Queue（后台，最低）的获取方法 */
dispatch_queue_t backgroundGlobalDispatchQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);

Global Dispatch Queue有4个优先级，分别是高优先级、默认优先级、低优先级和后台优先级。


图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》

3.2.4 dispatch_set_target_queue

dispatch_queue_create函数生成的两种Dispatch Queue的优先级都与默认优先级Global Dispatch Queue相同。如果需要修改队列的优先级，可以使用 dispatch_set_target_queue 改变顺序。

// 创建了默认优先级的Serial Queue
    dispatch_queue_t serialQueue = dispatch_queue_create("com.Sky.serialTest", NULL);
    // 获取一个低优先级Concurrent Queue
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
    // 将Serial Queue优先级变为低
    dispatch_set_target_queue(serialQueue, globalQueue);
dispatch_set_target_queue函数有两个参数：
  • 第一个参数是要设置优先级的队列。
  • 第二队参数是则是参考的的队列，使第一个参数与第二个参数具有相同的优先级。

🌰：

dispatch_queue_t queue0 = dispatch_queue_create("com.test.queue0", NULL);
dispatch_queue_t queue1 = dispatch_queue_create("com.test.queue1", NULL);
dispatch_queue_t queue2 = dispatch_queue_create("com.test.queue2", NULL);

dispatch_async(queue0, ^{
    NSLog(@"queue0");
});
dispatch_async(queue1, ^{
    NSLog(@"queue1");
});
dispatch_async(queue2, ^{
    NSLog(@"queue2");
});

执行结果如下：

queue2
queue0
queue1
使用dispatch_set_target_queue 之后:
dispatch_queue_t queue0 = dispatch_queue_create("com.test.queue0", NULL);
dispatch_queue_t queue1 = dispatch_queue_create("com.test.queue1", NULL);
dispatch_queue_t queue2 = dispatch_queue_create("com.test.queue2", NULL);

dispatch_set_target_queue(queue1, queue0);
dispatch_set_target_queue(queue2, queue0);

dispatch_async(queue0, ^{
    NSLog(@"queue0");
});
dispatch_async(queue1, ^{
    NSLog(@"queue1");
});
dispatch_async(queue2, ^{
    NSLog(@"queue2");
});

执行结果如下：

queue0
queue1
queue2
通过上述对比可知，如果在必须将不可并行执行的处理追加到多个Serial Dispatch Queue中，可使用dispatch_set_target_queue函数指定执行顺序，防止处理并行执行。

3.2.5 dispatch_after

dispatch_after API :指定时间追加到 Dispatch Queue。
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3ull * NSEC_PER_SEC);
dispatch_after(time, dispatch_get_main_queue(), ^{
        NSLog(@"waited at least three seconds");
    });
dispatch_after函数有三个参数：
  • 第一个参数是由dispatch_time函数生成的dispatch_time_t类型的参数。

dispatch_time函数获取的是从第一个参数指定的时间开始，到第二个参数指定的毫微秒单位时间后的时间。

上面的代码中第一个参数用的DISPATCH_TIME_NOW，表示从现在开始，第二个参数是2ull*NSEC_PER_SEC，表示延迟3秒，合起来就是从现在开始3秒后将Block追加到Main Dispatch Queue中。

ull 是 C 语言的数值字面量，表示“unsigned long long”
数值和NSEC_PER_SEC 的乘积得到的单位为毫微秒的数值。

  • 第二个参数是要追加的Dispatch Queue

  • 第三个参数则是需要执行的Block

在10秒后执行响铃🌰：
 __block NSDate *sendDate=[NSDate date]; // 获得当前时间
    NSDateFormatter *dateformatter=[[NSDateFormatter alloc] init]; // 设置时间格式
    [dateformatter setDateFormat:@"HH:mm"];
    NSString *timeBegain = [dateformatter stringFromDate:sendDate];
    NSLog(@"开始时间:%@",timeBegain);
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_SEC)), dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0), ^{
        sendDate = [NSDate date];
        NSString *timeEnd = [dateformatter stringFromDate:sendDate];
        NSLog(@"闹钟响时间:%@",timeEnd);
    });

执行结果如下：

 开始时间:16:50:00
 闹钟响时间:16:50:11

注意：dispatch_after是在指定时间之后将处理添加到queue中，但是在什么时候执行需要看queue中的情况！所以上述执行为11s是OK的

3.2.6 Dispatch Group

当追加到Dispatch Queue中的多个处理全部执行结束之后，我们通常都会需要执行结束处理。当使用Serial Queue的时候很简单，只需要将全部处理添加到一个Serial Queue中，结束处理在最后添加就可以实现。但是使用Concurrent Queue的时候，就很复杂。所以我们需要利用Dispatch Group。
例如，追加3个处理到Global Queue(Concurrent Queue)中，在3个处理结束后执行结束处理:

    // 创建一个Serial Queue,用于执行完成处理
    dispatch_queue_t serialQueue = dispatch_queue_create("com.Sky.serialTest", NULL);
    // 创建默认优先级Concurrent Queue
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
    // 创建Dispatch Group
    dispatch_group_t group = dispatch_group_create();
    // 添加操作
    dispatch_group_async(group, concurrentQueue, ^{printf("处理1\n");});
    dispatch_group_async(group, concurrentQueue, ^{printf("处理2\n");});
    dispatch_group_async(group, concurrentQueue, ^{printf("处理3\n");});
    // 操作完成执行
    dispatch_group_notify(group, serialQueue, ^{printf("处理全部完成\n");});

执行结果如下：

处理1
处理3
处理2
处理全部完成
除了dispatch_group_notify函数可以判断执行完成外，我们还可以利用dispatch_group_wait函数来进行判断。

将以上代码转换为dispatch_group_wait函数形式编写：

    // 创建一个Serial Queue,用于执行完成处理
    dispatch_queue_t serialQueue = dispatch_queue_create("com.Sky.serialTest", NULL);
    // 创建默认优先级Concurrent Queue
    dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
    // 创建Dispatch Group
    dispatch_group_t group = dispatch_group_create();
    // 添加操作
    dispatch_group_async(group, concurrentQueue, ^{printf("处理1\n");});
    dispatch_group_async(group, concurrentQueue, ^{printf("处理2\n");});
    dispatch_group_async(group, concurrentQueue, ^{printf("处理3\n");});
    // 操作完成执行
    long result = dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    if (result == 0) {
        dispatch_async(serialQueue, ^{printf("处理结束");});
    }
    else{
        // 处理没结束的程序段
    }

执行结果如下：

处理1
处理3
处理2
处理全部完成
关于dispatch_group_wait函数，有两个参数和一个返回值:
  • 第一个参数是dispatch_group_t类型，我们需要传递需要进行完成处理的Group；
  • 第二个参数为dispatch_time_t类型的变量。
  • 这个函数的返回值为0代表Group中的执行结束，不为0则代表指定时间到了，但是Group中的执行还没有完成。所以我们只需要对返回值进行判断，就能知道Group中的处理是否完成。上面的例子中，我们将时间设置为永久等待，所以只有Group中的处理全部完成才会得到返回值，所以返回值的值恒为0。
我们可以根据需要来设置由时间是否到达还是处理是否全部完成来执行收尾工作。相比较dispatch_group_notify而言，dispatch_group_wait函数更灵活一些。但在一般情况下，还是推荐dispatch_group_notify函数追加结果处理，从而简化源代码。

3.2.7 dispatch_barrier_async

当我们在多个读取中遇到了一个写入操作时，可以使用dispatch_barrier_async函数。

在使用dispatch_barrier_async函数的时候，它会等待当前Concurrent Dispatch Queue中的处理执行结束后，再将该处理追加到Concurrent Dispatch Queue，也就是
dispatch_barrier_async函数所携带的处理单独占用Concurrent Dispatch Queue。在执行dispatch_barrier_async函数的时候，它会屏蔽外界追加到Concurrent Dispatch Queue的操作。当它的处理执行完成后，Concurrent Dispatch Queue才开始继续正常添加操作。


图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》

3.2.8 dispatch_sync

  • async意味着非同步，意思就是处理各自管各自的执行；
    图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》

  • 而与之相反sync意味着同步，需要一个接一个的执行。
    图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》

🌰：

    // 创建一个Concurrent dispatch Queue
    dispatch_queue_t concurrentdispatchQueue = dispatch_queue_create("com.Sky.serialTest", DISPATCH_QUEUE_CONCURRENT);
    // Serial dispatch Queue
    dispatch_sync(concurrentdispatchQueue, ^{NSLog(@"1");});
    dispatch_sync(concurrentdispatchQueue, ^{NSLog(@"2");});
    dispatch_sync(concurrentdispatchQueue, ^{NSLog(@"3");});
    dispatch_sync(concurrentdispatchQueue, ^{NSLog(@"4");});
    dispatch_sync(concurrentdispatchQueue, ^{NSLog(@"5");});
    dispatch_sync(concurrentdispatchQueue, ^{NSLog(@"6");});

执行结果如下:

1
2
3
4
5
6

3.2.9 dispatch_apply

dispatch_apply函数是和Dispatch Group关联的API，它的作用是按指定的次数将制定的Block追到制定的Dispatch Queue中，并等待全部处理执行结束。
dispatch_apply函数有3个参数：

  • 第一个为重复次数
  • 第二个参数为追加对象的Dispatch Queue
  • 第三个参数的Block为带有参数的Blcok，其参数相当于for循环中的i的作用。

可用dispatch_apply来实现for循环的功能。

🌰：

 // 创建一个Concurrent dispatch Queue
    dispatch_queue_t concurrentdispatchQueue = dispatch_queue_create("com.Sky.serialTest", DISPATCH_QUEUE_CONCURRENT);
    dispatch_apply(10, concurrentdispatchQueue, ^(size_t index) {
        NSLog(@"%zu",index);
    });
    NSLog(@"完成");

执行结果如下：

3
1
2
4
5
6
7
8
9
0
完成

3.2.10 dispatch_suspend/dispatch_resume

  • dispatch_suspend函数用来挂起队列，队列挂起后，追加到队列中但还没有开始执行的处理，将暂停执行。
dispatch_suspend(Queue)// 挂起队列
  • dispatch_resume函数用来恢复队列，恢复队列后，暂停的处理继续执行。
dispatch_resume(Queue)// 暂停队列
注意: dispatch_set_target_queue函数中，目标队列如果被挂起，那么被转换的队列也会相同的挂起。但是被转换的队列被挂起，目标队列则不受影响！

3.2.11 Dispatch Semaphore

Dispatch Semaphore和操作系统原理中的信号量一样，都是用来避免数据竞争这一类问题的。
Dispatch Semaphore函数对数据竞争处理的对象的粒度更细。

Dispatch Semaphore是持有计数的信号，当它的计数大于1时，就会对其进行减1并执行处理；当计数为0或小于0的时候，就会等待下去。更加详细的请自行参阅：《操作系统原理》。

  • 图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》

🌰：

// 创建一个Concurrent dispatch Queue
    dispatch_queue_t concurrentdispatchQueue = dispatch_queue_create("com.Sky.serialTest", DISPATCH_QUEUE_CONCURRENT);
    // 提供一个信号量，也就意味着同时只有1个线程能对资源进行操作
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
    NSMutableArray *array = [[NSMutableArray alloc] init];
    for (int i =0; i<1000; ++i) {
        dispatch_async(concurrentdispatchQueue, ^{
            // 对信号量资源进行判断，当信号量大于等于1的时候，将信号量减一（相当于消耗一个资源），并返回，设置时间为永远等待
            // 如果此函数没有返回，则阻塞在这里，等待资源。
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            [array addObject:[NSNumber numberWithInt:i]];
            // 处理完成，信号量加一(相当于释放一个资源)
           dispatch_semaphore_signal(semaphore);
        });
    }

3.2.12 dispatch_once

dispatch_once函数是保证在应用程序执行中只执行一次指定处理的API。通常在建立单例中使用。

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 初始化单例
});




##3.2.13 Dispatch I/O

在读取较大文件的时候将文件切割开来，Dispatch I/O使用Global Dispatch Queue来同步读取,加快读取速度。利用dispatch_io_set_low_water
来设置一次读取的大小，dispatch_io_read
函数使用Global Dispatch Queue来并列读取，当读取结束后会回调Block中的代码进行相关资源合并。

######苹果中使用Dispatch I/O 和 Dispatch Data的例子。摘自[Apple System Log API里的源代码](http://opensource.apple.com/source/Libc/Libc-763.11/gen/asl.c)

// 创建串行队列
pipe_q = dispatch_queue_create("PipeQ", NULL);
// 创建 Dispatch I／O
pipe_channel = dispatch_io_create(DISPATCH_IO_STREAM, fd, pipe_q, ^(int err){
close(fd);
});

*out_fd = fdpair[1];  

// 该函数设定一次读取的大小（分割大小）  
dispatch_io_set_low_water(pipe_channel, SIZE_MAX);  
//  
dispatch_io_read(pipe_channel, 0, SIZE_MAX, pipe_q, ^(bool done, dispatch_data_t pipedata, int err){  
    if (err == 0) // err等于0 说明读取无误  
    {  
        // 读取完“单个文件块”的大小  
        size_t len = dispatch_data_get_size(pipedata);  
        if (len > 0)  
        {  
            // 定义一个字节数组bytes  
            const charchar *bytes = NULL;  
            charchar *encoded;  

            dispatch_data_t md = dispatch_data_create_map(pipedata, (const voidvoid **)&bytes, &len);  
            encoded = asl_core_encode_buffer(bytes, len);  
            asl_set((aslmsg)merged_msg, ASL_KEY_AUX_DATA, encoded);  
            free(encoded);  
            _asl_send_message(NULL, merged_msg, -1, NULL);  
            asl_msg_release(merged_msg);  
            dispatch_release(md);  
        }  
    }

/*
每当各个分割的文件块读取结束时，将含有文件块数据的 Dispatch Data(这里指pipedata) 传递给 dispatch_io_read 函数指定的读取结束时回调用的block，这个block拿到每一块读取好的Dispatch Data(这里指pipe data)，然后进行合并处理。
*/

    if (done)  
    {  
        dispatch_semaphore_signal(sem);  
        dispatch_release(pipe_channel);  
        dispatch_release(pipe_q);  
    }
}


#3.3 GCD 实现

##3.3.1 Dispatch Queue

> ######GCD 的Dispatch Queue提供系统级线程管理，提高执行效率。

GCD有2个执行任务的函数：
- 同步：dispatch_sync

dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

- 异步：dispatch_async

dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

> GCD同步和异步的区别

 > - 同步：只能在当前线程中执行任务，不具备开启新线程的能力；

 > - 异步：可以在新的线程中执行任务，具备可启新线程的能力；

 > ######注意： [具备开启线程的能力，但不代表一定会开启线程！！！]

GCD有2类队列：
- 并发队列:多个任务并发(同时)执行

- 串行队列:多个任务一个接着一个地执行

#####GCD的实现方式：
- 异步+并发 开启新线程 多个任务同时执行


// 创建默认优先级Concurrent Queue
dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
dispatch_async(concurrentQueue, ^{
    printf("处理1\n");
});
dispatch_async(concurrentQueue, ^{
    printf("处理2\n");
});
dispatch_async(concurrentQueue, ^{
    printf("处理3\n");
});

执行结果如下：

处理 1
处理 3
处理 2




- 异步+串行 开启新线程 任务依次执行

// 创建一个Serial Queue,用于执行完成处理
dispatch_queue_t serialQueue = dispatch_queue_create("com.Sky.serialTest", NULL);
dispatch_async(serialQueue, ^{
printf("处理1\n");
});
dispatch_async(serialQueue, ^{
printf("处理2\n");
});
dispatch_async(serialQueue, ^{
printf("处理3\n");
});

执行结果如下：

处理 1
处理 2
处理 3


- 同步+并发 不开启新线程 任务依次执行


// 创建默认优先级Concurrent Queue
dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
dispatch_sync(concurrentQueue, ^{
    printf("处理1\n");
});
dispatch_sync(concurrentQueue, ^{
    printf("处理2\n");
});
dispatch_sync(concurrentQueue, ^{
    printf("处理3\n");
});

执行结果如下：

处理 1
处理 2
处理 3





- 同步+串行 不开新线程 任务依次执行

// 创建一个Serial Queue,用于执行完成处理
dispatch_queue_t serialQueue = dispatch_queue_create("com.Sky.serialTest", NULL);
dispatch_async(serialQueue, ^{
printf("处理1\n");
});
dispatch_async(serialQueue, ^{
printf("处理2\n");
});
dispatch_async(serialQueue, ^{
printf("处理3\n");
});

执行结果如下：

处理 1
处理 2
处理 3

> ######注意：同步+主队列，容易造成死循环







##3.3.1 Dispatch Scource


> Dispatch Source是GCD中的一个基本类型，从字面意思可称为调度源，它的作用是当有一些特定的较底层的系统事件发生时，调度源会捕捉到这些事件，然后可以做其他的逻辑处理，调度源有多种类型，分别监听对应类型的系统事件。


######Dispatch Source都有哪些类型：
- Timer Dispatch Source：定时调度源。
- Signal Dispatch Source：监听UNIX信号调度源，比如监听代表挂起指令的SIGSTOP信号。
- Descriptor Dispatch Source：监听文件相关操作和Socket相关操作的调度源。
- Process Dispatch Source：监听进程相关状态的调度源。
- Mach port Dispatch Source：监听Mach相关事件的调度源。
- Custom Dispatch Source：监听自定义事件的调度源。

######Dispatch Source可处理的所有事件：
- ![图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》](http://upload-images.jianshu.io/upload_images/3239766-d7aaa9082f4d3fbb.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

> 注意：

> - DISPATCH_SOURCE_TYPE_DATA_ADD
当同一时间，一个事件的的触发频率很高，那么Dispatch Source会将这些响应以ADD的方式进行累积，然后等系统空闲时最终处理，如果触发频率比较零散，那么Dispatch Source会将这些事件分别响应。

> - DISPATCH_SOURCE_TYPE_DATA_OR 和上面的一样，是自定义的事件，但是它是以OR的方式进行累积

dispatch_source_t source = dispatch_source_create(dispatch_source_type_t type, uintptr_t handle, unsigned long mask, dispatch_queue_t queue)

 ######参数：
 - ![图片来自:《Objective-C高级编程：iOS与OS X多线程和内存管理》](http://upload-images.jianshu.io/upload_images/3239766-2010e2343ca1d79e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

🌰：

//倒计时时间
__block int timeout = 3;

//创建队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

//创建timer
dispatch_source_t _timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);

//设置1s触发一次，0s的误差
dispatch_source_set_timer(_timer,dispatch_walltime(NULL, 0),1.0*NSEC_PER_SEC, 0); //每秒执行

//触发的事件
dispatch_source_set_event_handler(_timer, ^{

    if(timeout<=0){ //倒计时结束，关闭

        //取消dispatch源
        dispatch_source_cancel(_timer);

    }
    else{

        timeout--;

        dispatch_async(dispatch_get_main_queue(), ^{

            //更新主界面的操作

            NSLog(@"~~~~~~~~~~~~~~~~%d", timeout);

        });
    }
});

//开始执行dispatch源
dispatch_resume(_timer);




#总结

######GCD是系统级线程管理，使用GCD可以提高执行效率。

######GCD两种队列, 一种是串行队列(Serial Dispatch Queue), 一种是并行队列(Concurrent Dispatch Queue)。可通过dispatch_queue_create函数创建。

######GCD还提供Main Dispatch Queue（主线程中执行的Dispatch Queue）与Global Dispatch Queue（全局的Concurrent Dispatch Queue）两种的队列。

> ######GCD的实现方式：
1. 异步+串行 开启新线程 任务依次执行
2. 异步+并发 开启新线程 多个任务同时执行
3. 异步+串行 开启新线程 任务依次执行
4. 同步+并发 不开启新线程 任务依次执行
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 158,736评论 4赞 362
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,167评论 1赞 291
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 108,442评论 0赞 243
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 43,902评论 0赞 204
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,302评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,573评论 1赞 216
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,847评论 2赞 312
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,562评论 0赞 197
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,260评论 1赞 241
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,531评论 2赞 245
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,021评论 1赞 258
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,367评论 2赞 253
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,016评论 3赞 235
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,068评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,827评论 0赞 194
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,610评论 2赞 274
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,514评论 2赞 269

推荐阅读更多精彩内容

  • iOS开发之多线程编程总结（二）
    背景 担心了两周的我终于轮到去医院做胃镜检查了！去的时候我都想好了最坏的可能（胃癌），之前在网上查的症状都很相似。...
    Dely阅读 9,178评论 21赞 42
  • 多线程知识总结
    NSThread 第一种:通过NSThread的对象方法 NSThread *thread = [[NSThrea...
    攻城狮GG阅读 738评论 0赞 3
  • 我的成长之路现在－未来连载005
    每天早上醒来，都希望是不平凡的一天。其实想想一个人平凡，那是当然；一个人不平凡，那是偶然；所有人的日子都平凡，才是...
    罗晨书阅读 340评论 0赞 2
  • 工具卡一一花时间训练
    【52天pd工具打卡 day43】训练是我们学生活技能的一项重要部分。不要期望没有经过一步步的训练就知道怎么做。“...
    陌上花开6361988阅读 306评论 0赞 0
  • 爱在相逢未见时
    我曾见过你 只是没有记起 我曾想过无数次邂逅 主角不知是谁 当遇见你时 所有的想象都与你重叠 哦，原来我一直在寻找...
    李木只阅读 341评论 2赞 4