iOS多线程：GCD (三) | gorpeln的个人博客

什么是CGD呢？以下摘自苹果的官方说明。

Grand Central Dispatch (GCD) 是异步执行任务的技术之一。应用程序中记述的线程管理用的代码是在系统级中实现的。开发者只需要定义想要执行的任务并追加到适当的Dispatch Queue中，GCD就能生成必要的线程并执行任务。
也就是说，GCD用我们难以置信的非常简洁的方法，实现了极为复杂的多线程编程。本文将罗列GCD的API及其用法实例来帮助大家了解GCD。

1、 GCD的队列和任务

GCD中有两个核心的概念：任务和队列

1.1 任务 (Dispatch Block)

任务：就是你想让系统执行的操作，GCD中通常是放在dispatch_block_t中的代码。任务分为同步执行(sync)和异步执行(async)两种执行方式。

同步执行(sync) : 任务被同步添加到指定的队列中，在该任务执行结束前会一直等待。不具备开启线程的能力，只能在当前线程中同步执行任务。
异步执行(async) : 任务被异步添加到指定队列中，不会等待该任务执行。具备开启线程的能力，可在新线程中执行任务。

注: 异步执行虽然具有开启新线程的能力，但只有该任务追加到并发队列才会开启新线程。

1.2 队列 (Dispatch Queue)

队列 (Dispatch Queue) : 是执行任务的的等待队列。开发者通过 dispatch_async或dispatch_sync函数等API，在dispatch_block_t中记述想要执行的任务并将其追加到Dispatch Queue中。Dispatch Queue按照追加的顺序（先进先出FIFO，First-In-First-Out）执行任务。队列分为 串行队列(Serial Dispatch Queue) 和 并发队列(Concurrent Dispatch Queue) 。

串行队列(Serial Dispatch Queue) : 只开启一条新的线程，追加到该队列中的任务会依次按顺序执行。
并发队列(Concurrent Dispatch Queue) : 会开辟多条新的线程，追加到该队列中的任务会并行执行。

注:

并发队列虽然有开启多条新线程的能力，但是只有在异步执行任务时才会开启新线程。
并发队列开启的新线程个数并不等同于任务个数，取决于队列的任务数、CPU核数、以及CPU负荷等当前系统状态。

2、GCD任务的创建、队列的获取和创建

2.1 创建同步及异步任务

dispatch_async(queue, ^{
    //创建异步任务
});
dispatch_sync(queue, ^{
    //创建同步任务
});

或者这样创建：

dispatch_block_t block = ^{
     //任务
};
dispatch_async(queue, block); //异步执行
dispatch_sync(queue, block);  //同步执行

2.2 获取系统主队列

主队列为特殊的串行队列，只有一个线程，即为主线程。主线程用于界面UI更新、用户事件交互等操作。所以比较耗时的操作(如查询数据库，数据请求等)都不应放在主线程中执行，会造成页面卡顿，影响用户体验。

dispatch_queue_t queue = dispatch_get_main_queue();

2.3 获取全局并发队列

系统为我们提供了四个全局的并发队列，我们可以直接获取，用来执行任务。

CPU执行任务处理时按照队列的优先级来分配资源，决定任务执行的先后顺序。但是苹果通过XUN内核用于Global Dispatch Queue 的线程并不能保证实时性 (Why? I don’t know.)，因此执行优先级只是大致的判断。

//第一个参数为队列优先级，第二个参数没用到，传0就行。
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

全局并发队列的优先级：

DISPATCH_QUEUE_PRIORITY_HIGH //高优先级
DISPATCH_QUEUE_PRIORITY_DEFAULT //默认优先级
DISPATCH_QUEUE_PRIORITY_LOW //低优先级
DISPATCH_QUEUE_PRIORITY_BACKGROUND //后台级

2.4 创建串行队列(Serial Dispatch Queue)

//1.第一个参数为队列名称，推荐使用工程ID这种逆序命名方式，便于管理和调试。
//2.第二个参数传NULL或DISPATCH_QUEUE_SERIAL，表示串行队列。
dispatch_queue_t queue = dispatch_queue_create("com.example.gcd", DISPATCH_QUEUE_SERIAL);

2.5 创建并发队列(Concurrent Dispatch Queue)

//1.第一个参数为队列名称，推荐使用工程ID这种逆序命名方式，便于管理和调试。
//2.第二个参数传DISPATCH_QUEUE_CONCURRENT，表示并发队列。

dispatch_queue_t queue = dispatch_queue_create("com.example.gcd",DISPATCH_QUEUE_CONCURRENT);

3、不同队列及任务的不同执行方式对比

20200406130431552

20200406130431554

由上我们可以看出：要想并发执行某些任务，只有使用〖并发队列 + 异步执行〗这种组合方式。这也是我们开发中最常用的组合方式。

3.1 串行队列 + 同步执行

- (void)serialAndSync {
    NSLog(@"begin ==== >>: %@",[NSThread currentThread]);

    dispatch_queue_t queue = dispatch_queue_create("com.example.gcd", DISPATCH_QUEUE_SERIAL);
    dispatch_block_t block1 = ^{
        sleep(2);
        NSLog(@"1     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block2 = ^{
        sleep(1);
        NSLog(@"2     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block3 = ^{
        NSLog(@"3     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_sync(queue, block1);
    dispatch_sync(queue, block2);
    dispatch_sync(queue, block3);
    NSLog(@"end   ==== >>: %@",[NSThread currentThread]);
}

输出结果:

begin ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}
1     ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}
2     ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}
3     ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}
end   ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}

结论:

1.所有任务都在主线程中执行(【串行+同步】不会开启新线程)。
2.所有任务按照追加顺序依次执行。
3.任务执行在begin和end之间，同步执行任务会阻塞主线程。

20200406130431555

3.2 串行队列 + 异步执行

- (void)serialAndAsync {
    NSLog(@"begin ==== >>: %@",[NSThread currentThread]);

    dispatch_queue_t queue = dispatch_queue_create("com.example.gcd", DISPATCH_QUEUE_SERIAL);
    
    dispatch_block_t block1 = ^{
        sleep(2);
        NSLog(@"1     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block2 = ^{
        sleep(1);
        NSLog(@"2     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block3 = ^{
        NSLog(@"3     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_async(queue, block1);
    dispatch_async(queue, block2);
    dispatch_async(queue, block3);

    NSLog(@"end   ==== >>: %@",[NSThread currentThread]);
}

输出结果:

begin ==== >>: <NSThread: 0x1d0078800>{number = 1, name = main}
end   ==== >>: <NSThread: 0x1d0078800>{number = 1, name = main}
1     ==== >>: <NSThread: 0x1c0073200>{number = 3, name = (null)}
2     ==== >>: <NSThread: 0x1c0073200>{number = 3, name = (null)}
3     ==== >>: <NSThread: 0x1c0073200>{number = 3, name = (null)}

结论:

1.【串行+异步】只开启一条新线程，所有任务按照追加顺序依次执行。
2.任务执行在end之后，异步执行任务不会阻塞主线程。

3.3 并发队列 + 同步执行

- (void)concurrentAndSync {
    NSLog(@"begin ==== >>: %@",[NSThread currentThread]);
    
    dispatch_queue_t queue = dispatch_queue_create("com.example.gcd", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_block_t block1 = ^{
        sleep(2);
        NSLog(@"1     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block2 = ^{
        sleep(1);
        NSLog(@"2     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block3 = ^{
        NSLog(@"3     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_sync(queue, block1);
    dispatch_sync(queue, block2);
    dispatch_sync(queue, block3);
    NSLog(@"end   ==== >>: %@",[NSThread currentThread]);
}

输出结果:

begin ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}
1     ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}
2     ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}
3     ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}
end   ==== >>: <NSThread: 0x1d4074f80>{number = 1, name = main}

结论:

1.所有任务都在主线程中执行(同步执行不会开启新线程)。
2.所有任务按照追加顺序依次执行。
3.任务执行在begin和end之间，同步执行任务会阻塞主线程。

3.4 并发队列 + 异步执行

- (void)concurrentAndAsync {
    NSLog(@"begin ==== >>: %@",[NSThread currentThread]);
    
    dispatch_queue_t queue = dispatch_queue_create("com.example.gcd", DISPATCH_QUEUE_CONCURRENT);
    dispatch_block_t block1 = ^{
        sleep(2);
        NSLog(@"1     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block2 = ^{
        sleep(1);
        NSLog(@"2     ==== >>: %@",[NSThread currentThread]);
    };
    
    dispatch_block_t block3 = ^{
        NSLog(@"3     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_async(queue, block1);
    dispatch_async(queue, block2);
    dispatch_async(queue, block3);
    NSLog(@"end   ==== >>: %@",[NSThread currentThread]);
}

输出结果:

begin ==== >>: <NSThread: 0x1d0263e00>{number = 1, name = main}
end   ==== >>: <NSThread: 0x1d0263e00>{number = 1, name = main}
3     ==== >>: <NSThread: 0x1d4269fc0>{number = 3, name = (null)}
2     ==== >>: <NSThread: 0x1c007f140>{number = 4, name = (null)}
1     ==== >>: <NSThread: 0x1c807e740>{number = 5, name = (null)}

结论:

1.任务执行在end之后 (不在主线程中执行，开启多条新线程执行)。不会阻塞主线程
2.所有任务并发执行，不会等待。

3.5 主队列 + 同步执行

- (void)mainAndSync {
    NSLog(@"begin ==== >>: %@",[NSThread currentThread]);
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_block_t block1 = ^{
        sleep(2);
        NSLog(@"1     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block2 = ^{
        sleep(1);
        NSLog(@"2     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block3 = ^{
        NSLog(@"3     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_sync(queue, block1);
    dispatch_sync(queue, block2);
    dispatch_sync(queue, block3);
    NSLog(@"end   ==== >>: %@",[NSThread currentThread]);
}

输出结果:

begin ==== >>: <NSThread: 0x1d0263e00>{number = 1, name = main}

结论:

发生死锁，任务不会执行。由于主队列为串行队列，主线程在执行mainAndSync 函数，而 mainAndSync 在等待主线程执行结束，就造成了互相等待，均不会执行。(开发中要极力避免这种情况)

20200406130431556

3.6 主队列 + 异步执行

- (void)mainAndAsync {
    NSLog(@"begin ==== >>: %@",[NSThread currentThread]);
    
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    dispatch_block_t block1 = ^{
        sleep(2);
        NSLog(@"1     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block2 = ^{
        sleep(1);
        NSLog(@"2     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_block_t block3 = ^{
        NSLog(@"3     ==== >>: %@",[NSThread currentThread]);
    };
    dispatch_async(queue, block1);
    dispatch_async(queue, block2);
    dispatch_async(queue, block3);
    NSLog(@"end   ==== >>: %@",[NSThread currentThread]);
}

输出结果:

begin ==== >>: <NSThread: 0x1d4076040>{number = 1, name = main}
end   ==== >>: <NSThread: 0x1d4076040>{number = 1, name = main}
1     ==== >>: <NSThread: 0x1d4076040>{number = 1, name = main}
2     ==== >>: <NSThread: 0x1d4076040>{number = 1, name = main}
3     ==== >>: <NSThread: 0x1d4076040>{number = 1, name = main}

结论:

1.由于主队列为串行队列(不会开启新线程)，所有任务都在主线程中执行。
2.任务在end之后执行，主队列中开启异步任务，不会开启新线程，会降低异步任务的优先级，在CPU空闲时才会执行该任务。

4. GCD中的 `dispatch_set_target_queue` 的用法及作用

4.1 更改Dispatch Queue 的执行优先级

通过 dispatch_queue_create 函数生成的GCD队列，不管是 Serial Dispatch Queue 还是 Concurrent Dispatch Queue，其优先级都为系统默认优先级，若想改变创建队列的优先级，则可以使用 dispatch_set_target_queue 函数。

// 第一个参数为需要更改优先级的queue, 第二个参数为参照队列，
// 将参照队列的优先级设为目标队列的优先级  
  
dispatch_queue_t queue = dispatch_queue_create("com.example.gcd",DISPATCH_QUEUE_SERIAL);
    
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
    
dispatch_set_target_queue(queue, globalQueue);

4.2 设置多个 Dispatch Queue 的层级

由上我们知道，通过 dispatch_queue_create 函数创建的 Serial Dispatch Queue 任务执行是同步的，同时只能执行一个任务，虽然GCD队列受到系统资源的限制，但通过 dispatch_queue_create 函数可以生成任意多个 Dispatch Queue。

当生成多个 Serial Dispatch Queue时，各个 Serial Dispatch Queue将并行执行。

如下代码：

- (void)setTargetQueue {
    
    dispatch_queue_t queue1 = dispatch_queue_create("com.example.gcd.queue1", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue2 = dispatch_queue_create("com.example.gcd.queue2", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue3 = dispatch_queue_create("com.example.gcd.queue3", DISPATCH_QUEUE_SERIAL);
        
    dispatch_async(queue1, ^{
        NSLog(@"1 ==== >>: %@",[NSThread currentThread]);
        sleep(3);
        NSLog(@"2 ==== >>: %@",[NSThread currentThread]);
    });
    
    dispatch_async(queue2, ^{
        NSLog(@"3 ==== >>: %@",[NSThread currentThread]);
        sleep(2);
        NSLog(@"4 ==== >>: %@",[NSThread currentThread]);
     });
    
    dispatch_async(queue3, ^{
        NSLog(@"5 ==== >>: %@",[NSThread currentThread]);
        sleep(1);
        NSLog(@"6 ==== >>: %@",[NSThread currentThread]);
    });
}

执行结果:

==== >>: <NSThread: 0x1d0066180>{number = 5, name = (null)}
==== >>: <NSThread: 0x1d4468e80>{number = 4, name = (null)}
==== >>: <NSThread: 0x1d0066700>{number = 3, name = (null)}
==== >>: <NSThread: 0x1d4468e80>{number = 4, name = (null)}
==== >>: <NSThread: 0x1d0066180>{number = 5, name = (null)}
==== >>: <NSThread: 0x1d0066700>{number = 3, name = (null)}

多次运行发现: 其中1、3、5的输出顺序不固定，多个任务并发执行。

假如此时我想让多个同步队列中的任务还是依次同步执行，或者让多个并发队列中的任务同步执行，我该怎么办呢？对，使用 dispatch_set_target_queue ，将三个队列指定到同一串行目标队列上，此时多个队列任务就会同步执行，不再是并发执行了。

如下代码:

- (void)setTargetQueue {
    
    dispatch_queue_t queue1 = dispatch_queue_create("com.example.gcd.queue1", DISPATCH_QUEUE_CONCURRENT);
    dispatch_queue_t queue2 = dispatch_queue_create("com.example.gcd.queue2", DISPATCH_QUEUE_CONCURRENT);
    dispatch_queue_t queue3 = dispatch_queue_create("com.example.gcd.queue3", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_queue_t targetQueue = dispatch_queue_create("com.example.gcd.targetQueue", DISPATCH_QUEUE_SERIAL);

    //指定到同一串行队列
    dispatch_set_target_queue(queue1, targetQueue);
    dispatch_set_target_queue(queue2, targetQueue);
    dispatch_set_target_queue(queue3, targetQueue);
    
    dispatch_async(queue1, ^{
        NSLog(@"1 ==== >>: %@",[NSThread currentThread]);
        sleep(3);
        NSLog(@"2 ==== >>: %@",[NSThread currentThread]);
    });

    dispatch_async(queue2, ^{
        NSLog(@"3 ==== >>: %@",[NSThread currentThread]);
        sleep(2);
        NSLog(@"4 ==== >>: %@",[NSThread currentThread]);
    });

    dispatch_async(queue3, ^{
        NSLog(@"5 ==== >>: %@",[NSThread currentThread]);
        sleep(1);
        NSLog(@"6 ==== >>: %@",[NSThread currentThread]);
    });
}

执行结果:

==== >>: <NSThread: 0x1d02602c0>{number = 3, name = (null)}
==== >>: <NSThread: 0x1d02602c0>{number = 3, name = (null)}
==== >>: <NSThread: 0x1d02602c0>{number = 3, name = (null)}
==== >>: <NSThread: 0x1d02602c0>{number = 3, name = (null)}
==== >>: <NSThread: 0x1d02602c0>{number = 3, name = (null)}
==== >>: <NSThread: 0x1d02602c0>{number = 3, name = (null)}

在必须将不可并行执行的多个任务追加到多个 Serial Dispatch Queue 中时，可使用 dispatch_set_target_queue函数，防止任务并发执行。

注: 一旦生成 Serial Dispatch Queue 并追加任务处理，系统对于一个 Serial Dispatch Queue 就会生成一条线程。假如生成 1000个 Serial Dispatch Queue ，那么就生成了 1000 条线程。此时会大量消耗内存，大幅度降低系统的响应性能。

5. GCD时间: `dispatch_time_t`

dispatch_time_t 为GCD的时间类，用于获取距离某个目标时间间隔的时间

计算相对时间：

dispatch_time_t time = dispatch_time(<#dispatch_time_t when#>, <#int64_t delta#>)
  
//第一个参数为某个目标时间，常用 DISPATCH_TIME_NOW,表示现在时间。
//第二个参数表示具体的时间长度，不能直接传 int或者float，需 (int64_t)3* NSEC_PER_SEC 这种形式。
  
注: delta单位是纳秒！
   
NSEC_PER_SEC  1000000000ull  每秒有1000000000纳秒
NSEC_PER_MSEC 1000000ull     每毫秒有1000000纳秒
USEC_PER_SEC  1000000ull     每秒有1000000微秒
NSEC_PER_USEC 1000ull        每微秒有1000纳秒
  
"ull"是C语言的数值字面量，是显示表明类型时使用的字符串（表示“unsigned long long”）。
  
例如 dispatch_time(DISPATCH_TIME_NOW, 3*NSEC_PER_SEC) 表示距离当前时间 3秒后的时间。

计算绝对时间:

dispatch_time_t time =dispatch_walltime(<#const struct timespec * _Nullable when#>, <#int64_t delta#>)
      
/* 第一个参数是一个 timespec 的结构体, 计算的是一个绝对的时间点,比如 2016年10月10日8点30分30秒, 
如果你不需要自某一个特定的时刻开始,可以传 NUll,表示自动获取当前时区的当前时间作为开始时刻，
第二个参数同上。*/
  
例如 dispatch_walltime(NULL, 3*NSEC_PER_SEC)表示距离当前时间 3秒后的时间。

struct timespec 类型的时间可以通过NSDate对象生成:

// 通过指定日期获取一个 dispatch_time_t 对象
- (dispatch_time_t)getDispatchTimeByDate:(NSDate *)date {
    NSTimeInterval interval;
    double second, subsecond;
    struct timespec time;
    dispatch_time_t milestone = 0;
    
    interval = [date timeIntervalSince1970];
    subsecond = modf(interval, &second);
    time.tv_sec = second;
    time.tv_nsec = dispatch_walltime(&time, 0);
    return milestone;
}

6. GCD延时操作: `dispatch_after`

我们可能经常会有这样的需求，想在3秒后执行某项操作，可能不限于3秒，总之，这种想在指定时间后执行操作的情况，可用 dispatch_after 来实现。

例如:

//第一个参数是 dispatch_time_t 的值(详见5)。
//第二个参数是执行的 Dispatch Queue 。
//第三个参数是要追加的操作。
  
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3*NSEC_PER_SEC);
    
dispatch_after(time, dispatch_get_main_queue(), ^{
    NSLog(@"Three seconds later...");
});

注: dispatch_after 函数并不是在指定的时间过后执行操作，而只是在指定时间后追加操作到 Dispatch Queue 中。

因为 Mian Dispatch Queue 在主线程的RunLoop 中执行，假如主线程的刷新频率为 60 帧，则追加的操作最快在3秒后执行，最慢则在 3 + 1/60 秒后执行，并且假如在Mian Dispatch Queue 中有大量操作要执行或者主线程本身有延迟的话，这个时间会更长。

7. Dispatch Group

7.1 dispatch_group_notify

假如在追加到 Dispatch Queue 中的多个操作全部结束后想要执行某项操作，假如只使用一个 Serial Dispatch Queue时，只需将结束操作追加到所有任务的最后即可实现。但是在使用 Concurrent Dispatch Queue或同时使用多个 Dispatch Queue时，实现起来就比较复杂了。

这时我们就可以使用 Dispatch Group 。下面我们来看一段代码:

- (void)dispatchGroup {
    NSLog(@"begin  ==== >>: %@",[NSThread currentThread]);

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"Task 1 ==== >>: %@",[NSThread currentThread]);
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"Task 2 ==== >>: %@",[NSThread currentThread]);
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"Task 3 ==== >>: %@",[NSThread currentThread]);
    });
    dispatch_group_notify(group, queue, ^{
        NSLog(@"Done!  ==== >>: %@",[NSThread currentThread]);
    });
    NSLog(@"end    ==== >>: %@",[NSThread currentThread]);
}

执行结果:

begin  ==== >>: <NSThread: 0x1d006f940>{number = 1, name = main}
end    ==== >>: <NSThread: 0x1d006f940>{number = 1, name = main}
Task 2 ==== >>: <NSThread: 0x1d0473700>{number = 3, name = (null)}
Task 3 ==== >>: <NSThread: 0x1c806cd00>{number = 4, name = (null)}
Task 1 ==== >>: <NSThread: 0x1c406c740>{number = 5, name = (null)}
Done!  ==== >>: <NSThread: 0x1c806cd00>{number = 4, name = (null)}

因为Global Dispatch Queue 为 Concurrent Dispatch Queue ，多个线程并发执行任务，所以任务执行顺序不定，但是执行结果 Done 一定是最后执行的。无论使用的是什么类型的 Dispatch Queue，Dispatch Group 都可以监测到这些任务执行的结束。

通过 dispatch_group_create() 函数生成 Dispatch Group .

dispatch_group_async与 dispatch_async 相同，都是追加 Block操作到指定 Dispatch Queue中。不同的是 dispatch_group_async 多了一个 Group 参数。

7.2 dispatch_group_wait

如上情况我们也可以使用 dispatch_group_wait 函数去实现，如下代码:

- (void)dispatchGroup {
    NSLog(@"begin  ==== >>: %@",[NSThread currentThread]);

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_async(group, queue, ^{
        sleep(3);
        NSLog(@"Task 1 ==== >>: %@",[NSThread currentThread]);
    });
    dispatch_group_async(group, queue, ^{
        sleep(1);
        NSLog(@"Task 2 ==== >>: %@",[NSThread currentThread]);
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"Task 3 ==== >>: %@",[NSThread currentThread]);
    });
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    NSLog(@"Done!  ==== >>: %@",[NSThread currentThread]);
    
    NSLog(@"end    ==== >>: %@",[NSThread currentThread]);
}

执行结果:

begin  ==== >>: <NSThread: 0x1d4262fc0>{number = 1, name = main}
Task 3 ==== >>: <NSThread: 0x1d026f040>{number = 3, name = (null)}
Task 2 ==== >>: <NSThread: 0x1c007ff40>{number = 4, name = (null)}
Task 1 ==== >>: <NSThread: 0x1cc07fe80>{number = 5, name = (null)}
Done!  ==== >>: <NSThread: 0x1d4262fc0>{number = 1, name = main}
end    ==== >>: <NSThread: 0x1d4262fc0>{number = 1, name = main}

从结果我们可以看出 dispatch_group_wait 一样可以达到我们想要的结果。但是不同之处也非常明显，dispatch_group_wait 会阻塞当前线程。

另外 dispatch_group_wait 函数可以指定等待的时间，传入 DISPATCH_TIME_FOREVER 则表示永远等待，直到所有任务执行结束。且该函数还有 long 型的返回值，返回0则表示所有任务都执行结束。

如我们修改代码如下:

long result = dispatch_group_wait(group, dispatch_time(DISPATCH_TIME_NOW, 2*NSEC_PER_SEC));
if (result == 0) {
    //所有任务都执行结束
    NSLog(@"Done!  ==== >>: %@",[NSThread currentThread]);
}else {
    //有任务尚未结束
     NSLog(@"Not Done!  ==== >>: %@",[NSThread currentThread]);
}

执行结果为:

begin  ==== >>: <NSThread: 0x1d0264f40>{number = 1, name = main}
Task 3 ==== >>: <NSThread: 0x1d066e980>{number = 3, name = (null)}
Task 2 ==== >>: <NSThread: 0x1cc07f9c0>{number = 4, name = (null)}
Not Done!  ==== >>: <NSThread: 0x1d0264f40>{number = 1, name = main}
end    ==== >>: <NSThread: 0x1d0264f40>{number = 1, name = main}
Task 1 ==== >>: <NSThread: 0x1c807fc80>{number = 5, name = (null)}

由上我们可以看出 dispatch_group_notify 与 dispatch_group_wait 两个函数的异同之处。在开发过程中可根据具体情况选择使用。

7.3 `dispatch_group_enter` 和 `dispatch_group_leave`

这两个函数配对使用，表示 Dispatch Group 开启任务和结束任务。这两种通知可以在多线程间自由穿梭，不局限于特定的某个线程。

dispatch_group_enter: 通知group，下面的任务马上要放到group中执行了。
dispatch_group_leave: 通知group，任务完成了，该任务要从group中移除了。

猜测：可能 Dispatch Group 内部有着一个类似引用计数的存在，调用 dispatch_group_enter 会加一，调用 dispatch_group_leave会减一，当该值为0时，则调用 dispatch_group_notify 和 dispatch_group_wait 函数。

当我们异步开启一个任务，并不指定特定的队列及线程时，可使用这两个函数去通知 Dispatch Group 任务的开启和结束。

如下代码:

- (void)dispatchGroup {
    NSLog(@"begin  ==== >>: %@",[NSThread currentThread]);

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_t group = dispatch_group_create();

    [self downloadImaegWithUrl:@"http://pic10.photophoto.cn/20090224/0036036802407491_b.jpg" InGroup:group];
    [self downloadImaegWithUrl:@"http://pic25.photophoto.cn/20121220/0036036800277861_b.jpg" InGroup:group];
    [self downloadImaegWithUrl:@"http://img.taopic.com/uploads/allimg/140806/235020-140P60H10661.jpg" InGroup:group];

    dispatch_group_notify(group, queue, ^{
        NSLog(@"Done!  ==== >>: %@",[NSThread currentThread]);
    });
    NSLog(@"end    ==== >>: %@",[NSThread currentThread]);
}

//利用 SDWebImage异步下载图片
- (void)downloadImaegWithUrl:(NSString *)url InGroup:(dispatch_group_t)group{
    dispatch_group_enter(group);//开启任务
    [[SDWebImageDownloader sharedDownloader] downloadImageWithURL:[NSURL URLWithString:url] options:(SDWebImageDownloaderContinueInBackground) progress:nil completed:^(UIImage * _Nullable image, NSData * _Nullable data, NSError * _Nullable error, BOOL finished) {
        NSLog(@"下载完成! ====>>: %@",[NSThread currentThread]);
        dispatch_group_leave(group);//结束任务
    }];
}

执行结果：

begin  ==== >>: <NSThread: 0x1d406ee00>{number = 1, name = main}
end    ==== >>: <NSThread: 0x1d406ee00>{number = 1, name = main}
下载完成! ====>>: <NSThread: 0x1d406ee00>{number = 1, name = main}
下载完成! ====>>: <NSThread: 0x1d406ee00>{number = 1, name = main}
下载完成! ====>>: <NSThread: 0x1d406ee00>{number = 1, name = main}
Done!  ==== >>: <NSThread: 0x1cc069cc0>{number = 3, name = (null)}

8. GCD栅栏（dispatch_barrier_sync）

当我们在访问数据库或者文件时，使用 Serial Dispatch Queue 可避免数据竞争导致程序异常的问题(多个写入操作不可并行执行)。但是这样的话，程序的执行效率就比较低。

为了高效率的进行访问，我们使用 Concurrent Dispatch Queue，并使用 dispatch_barrier_sync函数解决数据竞争问题。

dispatch_barrier_sync俗称栅栏，顾名思义，即可以将某些操作隔绝开来，互不影响。

假如我想在4次读取操作中间加入2次写入操作，如下代码：

- (void)dispatchBarrier {
    
    dispatch_queue_t queue = dispatch_queue_create("com.gcd.example", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"reading1 ===>>: %@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"reading2 ===>>: %@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        //写入操作
        NSLog(@"writing1 ===>>: %@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        //写入操作
        NSLog(@"writing2 ===>>: %@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"reading3 ===>>: %@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"reading4 ===>>: %@",[NSThread currentThread]);
    });
}

由 Concurrent Dispatch Queue 的性质我们可知，4次读取和2次写入均会并发执行，先后顺序不定，这样必然会导致数据竞争，出现异常。

修改代码: 我们只需将写入操作替换成 dispatch_barrier_sync 函数即可解决该问题。

dispatch_barrier_sync(queue, ^{
    //写入操作
    NSLog(@"writing1 ===>>: %@",[NSThread currentThread]);
});
dispatch_barrier_sync(queue, ^{
    //写入操作
    NSLog(@"writing2 ===>>: %@",[NSThread currentThread]);
 });

dispatch_barrier_sync 函数会等待追加到 Dispatch Queue 上的并行任务全部执行结束之后，再将指定的操作追加到 Dispatch Queue 中。该指定的操作执行完毕后，Dispatch Queue 才会恢复正常操作。开始处理其他任务。

因此修改后的代码执行顺序为 reading1和reading2并发执行在前，之后为 writing1 和 writing2 串行执行，最后 reading3和reading4并发执行。

20200406130431557

9. GCD信号量（dispatch_semaphore_t）

信号量(dispatch_semaphore_t)可以理解为有信号通过，无信号则等待。具体的我们慢慢来分析。

与信号量有关的主要有三个函数:

dispatch_semaphore_create(<#long value#>)
//创建一个信号量，传入一个long型的信号值.
//传入信号值为大于或者等于0的值，否则将返回 NULL.

dispatch_semaphore_wait(<#dispatch_semaphore_t  _Nonnull dsema#>, <#dispatch_time_t timeout#>)
//与 dispatch_group_wait(详见7.2)类似，会阻塞当前线程，并有返回值.
//当当前信号量等于0时，持续等待.
//当当前信号量大于0时，执行返回，并将当前信号量减一.

dispatch_semaphore_signal(<#dispatch_semaphore_t  _Nonnull dsema#>)
//该函数会将当前信号量加一.

我理解的信号量主要有三个作用:线程同步、线程锁、控制并发数.

9.1 线程同步

先看代码：

__block int count = 0;
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    count = 10;
});
NSLog(@"%d",count);

由异步并发执行我们可知，此时输出的count值为 0。假如我想让主线程保持与任务异步线程一致，输出 count 值为10，我该怎么做呢？

修改代码：

dispatch_semaphore_t semphore = dispatch_semaphore_create(0);    
__block int count = 0;     

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{  
    count = 10;  
    dispatch_semaphore_signal(semphore);  
});  
dispatch_semaphore_wait(semphore, DISPATCH_TIME_FOREVER);  
NSLog(@"%d",count);  

分析:
我们初始化了一个值为0信号量，执行 dispatch_semaphore_wait 函数时发现信号量为0，则会等待信号，执行完 count = 10 后，通过 dispatch_semaphore_signal 函数获得一个信号量，此时 dispatch_semaphore_wait 监测到信号量大于0，则执行返回，线程继续执行，输出 count 为10。这就保证了线程间的同步了。

9.2 线程锁

假如我想异步并发执行1000次任务，给同一块内存区间赋值，会发生什么情况呢?
先看代码:

NSMutableArray *temArr = @[].mutableCopy;
    for (int i = 0; i < 1000; i++) {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            [temArr addObject:[NSString stringWithFormat:@"%d",i]];
        });
    }

运行会发现程序异常崩溃的概率相当高，这是因为我们异步并发的操作同一内存导致数据错乱引起的异常。

使用线程锁修改代码：

dispatch_semaphore_t semphore = dispatch_semaphore_create(1);
NSMutableArray *temArr = @[].mutableCopy;
for (int i = 0; i < 1000; i++) {
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //等待信号
        dispatch_semaphore_wait(semphore, DISPATCH_TIME_FOREVER);
        //到这里，信号量会减一
        [temArr addObject:[NSString stringWithFormat:@"%d",i]];
        dispatch_semaphore_signal(semphore);
        //信号量加一
    });
}

通过这种方法，保证了同一时间只有一个操作去改变内存。当然在实际操作中我们不会这样去for循环使用，通常是设置一个全局的 dispatch_semaphore_t 对象，将需要加锁的操作放在，dispatch_semaphore_wait 和 dispatch_semaphore_signal 函数中间。保证唯一性。

例如：

@property (nonatomic, copy) NSString *name;
@property (nonatomic, strong) dispatch_semaphore_t semaphore;

self.semaphore = dispatch_semaphore_create(1);

- (void)setName:(NSString *)name {
    dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
    _name = name;
    dispatch_semaphore_signal(self.semaphore);
}

9.3 控制并发数

当我们在处理大量线程时，怎么来进行并发控制呢，假如我有1000个任务要执行，但是同时执行的并发数我想控制在10个，该怎么做呢？以前我们使用NSOperationQueue可以控制并发数，在GCD中怎么简单快速的控制并发呢？那就是使用 dispatch_semaphore_t.

先看代码:

- (void)dispatchSemaphore {

    dispatch_group_t group = dispatch_group_create();
    
    dispatch_semaphore_t semphore = dispatch_semaphore_create(10);
    
    for (int i = 0; i < 100; i++) {
        dispatch_semaphore_wait(semphore, DISPATCH_TIME_FOREVER);
        
        dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            NSLog(@"%d ===>>: %@",i,[NSThread currentThread]);
            sleep(2);
            dispatch_semaphore_signal(semphore);
        });
    }
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    NSLog(@"end");
}

首先我们创建了一个值为10的信号量，每次循环会减少一个信号量，执行结束会增加一个信号量，当执行操作为10个时，此时信号量为0，dispatch_semaphore_wait 函数将会等待，如此则保证了最多同时有10个任务在执行。由此看出，通过 dispatch_semaphore_t 来控制并发数简单快速又实用。

10. dispatch_suspend / dispatch_resume

当追加大量的处理任务到 Dispatch Queue 时，有时候希望不执行某些已经追加的任务，在这种情况下，只需要挂起 Dispatch Queue即可，当可以执行时再恢复。

dispatch_suspend : 挂起指定的 Dispatch Queue。可理解为暂停执行。
dispatch_resume : 恢复指定的 Dispatch Queue。可理解为继续执行。

值得注意的是，dispatch_suspend 对于正在执行的任务是没有影响的，挂起后，只有 Dispatch Queue 中尚未执行的任务停止执行。而恢复则使得这些任务能够继续执行。

11. GCD快速遍历（dispatch_apply）

dispatch_apply 函数是dispatch_sync函数和 Dispatch Group的关联API。该函数按指定次数将指定的 Block 追加到指定的 Dispatch Queue中，并等待全部处理执行结束。

如下代码:

- (void)dispatchApply {
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_apply(10, queue, ^(size_t index) {
        NSLog(@"%zu",index);
    });
    NSLog(@"end");
}

执行结果:

因为在 Global Dispatch Queue 中执行操作，10个任务并发执行，但是最后的end一定在最后的位置上。因为 dispatch_apply 会等待全部任务执行结束。

另外，由于dispatch_apply 函数与 dispatch_sync函数一样，会等待任务结束，阻塞当前线程，因此推荐在 dispatch_async 函数中异步执行 dispatch_apply 函数。

例如:

- (void)dispatchApply {
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //异步执行
    dispatch_async(queue, ^{
        dispatch_apply(10, queue, ^(size_t index) {
            NSLog(@"%zu",index);
        });
        
        //等待处理结束
        dispatch_async(dispatch_get_main_queue(), ^{
            //主线程回调，刷新UI
            NSLog(@"end");
        });
    });
    NSLog(@"main");
}

12. GCD单例 (dispatch_once)

dispatch_once函数是保证在应用程序执行中只执行一次指定处理的API。

下面这种经常出现的用来进行初始化的代码可通过 dispatch_once 函数来简化。

static int count = 0;
    if (count == 0) {
        //在这里初始化
        count = 100;
    }
使用 dispatch_once 函数：

static int count = 0;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        //在这里初始化
        count = 100;
    });

代码看起来并没有太大的变化。但是通过 dispatch_once 函数，该代码即使在复杂的多线程环境下执行，也可保证百分之百安全。之前的代码在大多数情况下也是安全的。但是在多核CPU中，读取数据时，有可能会多次执行初始化处理。而用 dispatch_once 函数就不必担心这样的问题。这就是所说的单例模式，在生成单例对象时使用。

13. GCD的实际使用

多线程使用总结 GCD的实际使用 (四)

20200406130431551

1、 GCD的队列和任务

1.1 任务 (Dispatch Block)

1.2 队列 (Dispatch Queue)

2、GCD任务的创建、队列的获取和创建

2.1 创建同步及异步任务

2.2 获取系统主队列

2.3 获取全局并发队列

2.4 创建 串行队列(Serial Dispatch Queue)

2.5 创建 并发队列(Concurrent Dispatch Queue)

3、 不同队列及任务的不同执行方式对比

3.1 串行队列 + 同步执行

3.2 串行队列 + 异步执行

3.3 并发队列 + 同步执行

3.4 并发队列 + 异步执行

3.5 主队列 + 同步执行

3.6 主队列 + 异步执行

4. GCD中的 dispatch_set_target_queue 的用法及作用

4.1 更改Dispatch Queue 的执行优先级

4.2 设置多个 Dispatch Queue 的层级

5. GCD时间: dispatch_time_t

6. GCD延时操作: dispatch_after

7. Dispatch Group

7.1 dispatch_group_notify

7.2 dispatch_group_wait

7.3 dispatch_group_enter 和 dispatch_group_leave

8. GCD栅栏 （dispatch_barrier_sync）

9. GCD信号量 （dispatch_semaphore_t）

9.1 线程同步

9.2 线程锁

9.3 控制并发数

10. dispatch_suspend / dispatch_resume

11. GCD快速遍历 （dispatch_apply）

12. GCD单例 (dispatch_once)

13. GCD的实际使用

2.4 创建串行队列(Serial Dispatch Queue)

2.5 创建并发队列(Concurrent Dispatch Queue)

3、不同队列及任务的不同执行方式对比

4. GCD中的 `dispatch_set_target_queue` 的用法及作用

5. GCD时间: `dispatch_time_t`

6. GCD延时操作: `dispatch_after`

7.3 `dispatch_group_enter` 和 `dispatch_group_leave`

8. GCD栅栏（dispatch_barrier_sync）

9. GCD信号量（dispatch_semaphore_t）

11. GCD快速遍历（dispatch_apply）