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，总共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全局队列


    dispatch_set_target_queue(self.serialQueue, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0));
    dispatch_set_target_queue(self.serialQueue, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0));
线程个数为64但是发现无论依附的是高优先级还是低优先级，串行队列都会从开始分配任务就执行；说明当串行队列和并行队列依附于同一并行队列时，串行队列的优先级总是高于并行


### 六、串行队列获取全局队列时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多个任务，以次轮换。说明对于对于依附于同一队列的不同队列，也会有类似系统对线程调度，分配时间片一样来调度，只是所依据的不再是时间，而是任务个数 


### 总结
1.gcd线程池，系统会创建64个线程给dispatch_get_global_queue获取的4个并行队列，当各优先级都有任务时优先保证高优先级的；如果串行队列依附的是系统的并行队列，则优先级最高。
2.如果自己再创建串行队列，系统会在64个线程基础上再创建线程给串行队列。
3.dispatch_get_global_queue（DISPATCH_QUEUE_PRIORITY_HIGH，1）
flags处开参传入非0会获取到overcommit队列
4.如果设置并行队列依附于overcommit队列，系统会转交给DISPATCH_QUEUE_PRIORITY_DEFAULT
5.对于依附于同一队列的不同队列，也会有类似系统对线程调度，分配时间片一样来调度，只是所依据的不再是时间，而是任务个数 。不以时间而以任务个数肯定也是为了提高效率


系统为串行队列单独创建线程应该是考虑到：
1.串行队列如果不单独创建，很容易被执行更早的并行列队抢占完线程，导致并行队列只能等待。
2.就算是抢到一个线程，执行完一个任务，下一个任务也不一定能抢到，这样串行队列就直接成悲剧了，只能执行一个任务，等一会，再执行一个。
###其他
1.以后有时间再测试创建10000个串行队列，看系统会创建几个线程，上限会是多少
2.到底为4000多多个少，这个需要再查源码了。