GCD会创建多少个线程

96
反调唱唱
2018.01.14 00:23* 字数 2234

关于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对于不同程序是否是共享的,

日记本