GCD会创建多少个线程
关于GCD队列，系统队列编号有11个，1为主队列，2为管理队列，3保留；4-11为8个全局队列，优先级分别为LOW、DEFAULT、HIGH 和 BACKGROUND，4个队列overcommit为YES，4个为NO;
如果为overcommit队列，有新任务就会重新开辟新的线程,其中 dq->dq_width = UINT32_MAX;表示这些队列不限制并发数。
任何自己创建的队列默认都依附于系统的DEFAULT队列，串行的依附于DISPATCH_ROOT_QUEUE_IDX_DEFAULT_OVERCOMMIT_PRIORITY；并行队列依附于DISPATCH_ROOT_QUEUE_IDX_DEFAULT_PRIORITY
当然也可以自己再重新设置所依附的队列。
GCD号称非常高效，底层用的线程池，就会想系统怎么调度才能更好效，线程池会创建多少个线程：系统如果创建非常多线程，那队列的意义就没有了，来个任务就创建线程，就不用排队了，并且如果线程过多肯定会伴随着性能下降。那就测试一下系统到底会创建多少个线程
一、分别创建10个，100个和10000个并行任务
NSInteger taskCount = 10/10000/100;
for (int i = 0; i < taskCount; i++) {
dispatch_async(self.queue, ^{
NSLog(@"thread: @", [NSThread currentThread]);
});
}
最终通过log看taskCount为10时，线程个数大约是八九个，看情况不定；taskCount为100和10000时线程num是从3到66(偶尔也会有2到65)，总共64个，64是2的6次方，也比较符合程序的一贯风格；因为任务比较轻，所以当任务比较少时到后面分配任务时前面的任务已经做完，所以会在原来的线程上执行任务；一旦任务比较多时，就会全力分配线程。
二、两个并行队列各分配10000个任务
结果依然是64，因为都是依附于DISPATCH_ROOT_QUEUE_IDX_DEFAULT_PRIORITY，DISPATCH_ROOT_QUEUE_IDX_DEFAULT_PRIORITY默认为64，不管他那几个依附于DISPATCH_ROOT_QUEUE_IDX_DEFAULT_PRIORITY，结果都一样
三、并行队列设置不同优先级：
for (int i = 0; i < taskCount; i++) {
dispatch_async(self.queue, ^{
NSLog(@"thread: @", [NSThread currentThread]);
});
}
for (int i = 0; i < taskCount; i++) {
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
NSLog(@"DISPATCH_QUEUE_PRIORITY_HIGH thread: @", [NSThread currentThread]);
});
}
经过测试发现先输出的是DISPATCH_QUEUE_PRIORITY_DEFAULT(self.queue)的部分然后就开始输出DISPATCH_QUEUE_PRIORITY_HIGH部分，DISPATCH_QUEUE_PRIORITY_HIGH全部输出完了后才继续输出DISPATCH_QUEUE_PRIORITY_DEFAULT(self.queue)；线程个数依然为64。
先输出了DISPATCH_QUEUE_PRIORITY_DEFAULT(self.queue)部分是因为在发送DISPATCH_QUEUE_PRIORITY_DEFAULT(self.queue)全部任务期间还没有轮到DISPATCH_QUEUE_PRIORITY_HIGH创建任务，一旦等有了DISPATCH_QUEUE_PRIORITY_HIGH任务就立即执行高优先级的任务了。
四、添加串行队列：
for (int i = 0; i < taskCount; i++) {
dispatch_async(self.serialQueue, ^{
NSLog(@"serialQueue thread: @", [NSThread currentThread]);
});
}
NSInteger taskCount = 10000;
for (int i = 0; i < taskCount; i++) {
dispatch_async(self.queue, ^{
NSLog(@"thread: @", [NSThread currentThread]);
});
}
线程个数为65个，说明当串行队列加入时肯定会创建一个线程对应；同时创建两个串行队列然后就会输出66个线程
五、串行队列重新设置依附于一个非overcommit全局队列
int sleepTime = 100000;
for (int i = 0; i < taskCount; i++) {
dispatch_async(self.queue, ^{
self.count++;
usleep(sleepTime);
NSLog(@"thread :%@ count %ld", [NSThread currentThread] ,self.count);
});
}
for (int i = 0; i < taskCount; i++) {
dispatch_async(self.serialQueue2, ^{
self.count++;
NSLog(@"DISPATCH_QUEUE_PRIORITY_HIGH thread :%@ count %ld", [NSThread currentThread] ,self.count);
});
}
// 这个结论并不对，测试发现队列设置不同优先级并没有起作用，暂时忽略这一条，找到原因重新修改
线程个数为64，但是发现，串行队列一单开始执行就会守着一个线程一直执行不会再被抢走；并且串行队列不管依附于哪个级别的非overcommit全局队列，都能会在self.queue的任务执行4000多个时切换过来，说明串行队列依附于非overcommit全局队列时不受优先级限制都会被切换过来
六、串行队列获取全局队列时flag处设置为1
不管是苹果官方文档，还是其他人博客都会说flag处保留字段暂时都为0，看到过一段gcd源码
dispatch_queue_t
dispatch_get_global_queue(long priority, unsigned long flags)
{
if (flags & ~DISPATCH_QUEUE_OVERCOMMIT) {
return NULL;
}
return _dispatch_get_root_queue(priority,
flags & DISPATCH_QUEUE_OVERCOMMIT);
}
从这段源码中flags设置为1获取到的应该是overcommit的队列，那如果串行队列依附于overcommit的，那线程个数应该是65了；
经测试果然为65，说明flags功能就是来区分获取的是overcommit还是非overcommit队列的，只是苹果暂时不想让调用罢了
七、那如果把一个并行队列依附于一个overcommit队列，是不是可以创建无数个线程？想想就很激动
测试结果为64个，看来苹果对依附于'overcommit队列'的并行队列还是有限制的，依然限制为64个线程。
八、那我如果两个并行队列依附于两个优先级的overcommit队列会出现什么呢？
dispatch_set_target_queue(self.queue, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, -1));
dispatch_set_target_queue(self.queue2, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, -1));
for (int i = 0; i < taskCount; i++) {
dispatch_async(self.queue, ^{
self.count++;
NSLog(@"thread :%@ count %ld", [NSThread currentThread] ,self.count);
});
}
for (int i = 0; i < taskCount; i++) {
dispatch_async(self.queue2, ^{
self.count++;
NSLog(@"queue2 thread :%@ count %ld", [NSThread currentThread] ,self.count);
});
}
经测试，系统并没有创建128个线程，而依然是64个，并且并不是优先输出依附于高优先级的并行队列，而是各个队列的输出了4000多个轮流几次输出完毕。（他那两个默认优先级队列也是轮流4000多）
说明当并行队列依附于overcommit队列时系统会转交给DEFAULT优先级的非overcommit队列。
九、两个同级别并行队列会怎么分配线程
int sleepTime = 0/1000/10000/100000;
for (int i = 0; i < taskCount; i++) {
dispatch_async(self.queue, ^{
self.count++;
usleep(sleepTime);
NSLog(@"thread :%@ count %ld", [NSThread currentThread] ,self.count);
});
}
for (int i = 0; i < taskCount; i++) {
dispatch_async(self.queue2, ^{
self.count++;
usleep(sleepTime);
NSLog(@"queue2 thread :%@ count %ld", [NSThread currentThread] ,self.count);
});
}
无认是否sleep()，以及休眠的时间是多少都是会先执行self.queuer 4000多个任务，再执行self.queue2的4000多个任务，以次轮换。说明对于对于依附于同一队列的不同队列，也会有类似系统对线程调度，分配时间片一样来调度，只是所依据的不再是时间，而是任务个数
十、高低优先级队列同时有任务怎么分配
第一想法当然是有高优先级肯定先执行高优先级，但是事情并没有这么简单。既然两个同级别队列会4000个多任务交替执行，那么高低优先级可能也会有些不同的策略。
for (int i = 0; i < taskCount; i++) {
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
self.count++;
NSLog(@"thread :%@ count %ld", [NSThread currentThread] ,self.count);
if (i == 200) {
for (int j = 0; j < taskCount; j++) {
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), ^{
self.count++;
NSLog(@"insert queue thread :%@ count %ld", [NSThread currentThread] ,self.count);
});
}
}
});
}
这种先创建部分任务放到高优先级队列，再创建任务放到低优先级队列，最终是会先执行完高优先级任务。
如果反过来
for (int i = 0; i < taskCount; i++) {
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{
self.count++;
NSLog(@"thread :%@ count %ld", [NSThread currentThread] ,self.count);
if (i == 200) {
NSLog(@" insertBegin");
for (int j = 0; j < taskCount; j++) {
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
self.count++;
NSLog(@"insert queue thread :%@ count %ld", [NSThread currentThread] ,self.count);
});
}
NSLog(@" insertEnd");
}
});
}
先创建200任务放到低优先级队列，再同时创建任务放到高低优先级队列，执行情况不一：
1.依然先执行完低优先级队列里的任务
2.先执行低优先级队列任务，然后开始交替执行
3无论何会在低优先级任务执行4000多个后再切换
十一、不同系统，不同手机（不同核数）
ip5（双核）,9.3.1的系统：会创建64个线程
ip6（双核 ），8.1.1的系统：会创建三百多个线程
模拟器上，都是9以上的系统：会创建64个线程
总结
1.gcd线程池，系统会创建64个线程给dispatch_get_global_queue获取的4个并行队列，当各优先级都有任务时优先保证高优先级的；如果串行队列依附的是系统的并行队列，则优先级最高。
2.如果自己再创建串行队列，系统会在64个线程基础上再创建线程给串行队列。
3.串行队列依附于非overcommit全局队列时，不受优先级限制，都能抢到线程，且抢到后会一直占用此线程执行任务直到执行完
4.dispatch_get_global_queue（DISPATCH_QUEUE_PRIORITY_HIGH，1）
flags处开参传入非0会获取到overcommit队列
5.如果设置并行队列依附于overcommit队列，系统会转交给DISPATCH_QUEUE_PRIORITY_DEFAULT
6.对于依附于同一队列的不同队列，也会有类似系统对线程调度，分配时间片一样来调度，只是所依据的不再是时间，而是任务个数 。不以时间而以任务个数肯定也是为了提高效率
系统为串行队列单独创建线程应该是考虑到：
1.串行队列如果不单独创建，很容易被执行更早的并行列队抢占完线程，导致并行队列只能等待。
2.就算是抢到一个线程，执行完一个任务，下一个任务也不一定能抢到，这样串行队列就直接成悲剧了，只能执行一个任务，等一会，再执行一个。
其他
1.以后有时间再测试创建10000个串行队列，看系统会创建几个线程，上限会是多少。
2.到底为4000多多个少，这个需要再查源码了。
3.不同优先级队列调度的逻辑，也需要查源码。
4.gcd对于不同程序是否是共享的，
