ios的gcd dispatch_queue可以理解为是一种线程池化技术的实现。
1，全局一共几个池？
除了主线程所在的池1个， 其它全局池4个，分别是DISPATCH_QUEUE_PRIORITY_DEFAULT，DISPATCH_QUEUE_PRIORITY_LOW，DISPATCH_QUEUE_PRIORITY_HIGH
DISPATCH_QUEUE_PRIORITY_BACKGROUND
2，一个池最多支持几个线程同时工作？
64个
3，多个池，一共最多几个线程同时工作？
不管几个池，总共64个线程同时工作，优先级高的池获得的可活跃线程数多与优先级低的池，但也不是滴水不漏，低优先级的也能获得少量活跃线程。
image.png
4，自己创建的池跟系统的4个全局池模式是否一样？
一样，也是最多64个。
5， 串行池可以开多少？
6p上最多到了6248个池。
池可以开（一个池对应一个线程），但是同时工作的也是最多64个，其余的pending状。
image.png
注：以上测试，[NSProcessInfo processInfo].activeProcessorCount个数无关。
在6p真机是2个，mac上的模拟器，ios9的4s，ios11的iphone8都是4.貌似模拟器的cpu核数根pc机相同。
6，提出疑问？
YY做了一个队列池。管理池的池。
YYDispatchQueuePool的建议是：
默认创建activeProcessorCount相同个数的串行池（DISPATCH_QUEUE_SERIAL）（2个或4个，cpu核数），最多32个池。
@interface ViewController ()
@end
@implementation ViewController
//////4个全局池
- (IBAction)do:(id)sender {
NSLog(@"开始了");
//[self test1];
//[self test2];
//[self test3];
// [self test4];
// [self.class testTargetQueue];
[self testTargetQueueIfChangetoMainthread];
}
////多个池，一共最多几个线程同时工作
// 几个池总共64个线程同时工作，优先级高的池获得的可活跃线程数多与优先级低的池，但也不是滴水不漏，低优先级的能获得少量活跃线程。
-(void)test3{
//////一个池，64个线程同时工作
dispatch_queue_t queue1 =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
for (NSInteger i = 0; i < 100; i++) {
dispatch_async(queue1, ^{
NSLog(@"开始%li", (long)i );
sleep(10);
NSLog(@"结束%li", (long)i );
});
}
dispatch_queue_t queue2 =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
for (NSInteger i = 0; i < 100; i++) {
dispatch_async(queue2, ^{
NSLog(@"第二个池开始%li", (long)i );
sleep(10);
NSLog(@"第二个池结束%li", (long)i );
});
}
NSAssert(queue1!=queue2, @"asdfasd");
}
/////测试全局池一共有几个？
// 全局4个池+ mainQueue一共5个
-(void)test2{
dispatch_queue_t queue1 =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_queue_t queue2 =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
dispatch_queue_t queue3 =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_queue_t queue4 =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
dispatch_queue_t queue11 =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_queue_t queue22 =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
dispatch_queue_t queue33 =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
dispatch_queue_t queue44 =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
NSAssert(queue1==queue11, @"asdfasd");
NSAssert(queue2==queue22, @"asdfasd");
NSAssert(queue3==queue33, @"asdfasd");
NSAssert(queue4==queue44, @"asdfasd");
NSAssert((queue1!=queue2 &&queue1!=queue3&&queue1!=queue4&&queue2!=queue3&&queue2!=queue4&&queue3!=queue4), @"asdfasd");
}
/////测试一个池最多支持几个线程同时工作？
// 64个
-(void)test1{
//////一个池，64个线程同时工作
//dispatch_queue_t queue =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
/// 自己创建的池跟系统的4个全局池模式是否一样？
///相同
dispatch_queue_t queue= dispatch_queue_create("池1", DISPATCH_QUEUE_CONCURRENT);
for (NSInteger i = 0; i < 100; i++) {
dispatch_async(queue, ^{
NSLog(@"开始%li", (long)i );
sleep(10);
NSLog(@"结束%li", (long)i );
});
}
}
///池可以开（一个池对应一个线程），但是同时工作的最多64个，其余的pending状
-(void)test4{
for (NSInteger i = 0; i< 10000; i++) {
dispatch_queue_t queue= dispatch_queue_create([NSString stringWithFormat:@"池%d",i].UTF8String, DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
NSLog(@"开始%li", (long)i );
sleep(10);
NSLog(@"结束%li", (long)i );
});
}
}
////不管几个池，同时最多64个线程工作。
- (void)viewDidLoad {
[super viewDidLoad];
int count = (int)[NSProcessInfo processInfo].activeProcessorCount;
NSLog(@"%d",count);
//
// ///测试最大int32_t
// int32_t i =0;
// while (1) {
// i++;
// if (i<0) {
// NSLog(@"%d", i);
// break;
// }
// }
// int j = i-i ;
// NSLog(@"%d", j);
//
//
//
}
//////dispatch_set_target_queue切换到目标线程执行代码
////切换到主线程了
-(void)testTargetQueueIfChangetoMainthread {
dispatch_queue_t targetQueue = dispatch_get_main_queue();
dispatch_queue_t queue1 = dispatch_queue_create("test.1", DISPATCH_QUEUE_SERIAL);
///如果不加，会导致应用崩溃
dispatch_set_target_queue(queue1, targetQueue);
dispatch_async(queue1, ^{
self.view.layer.masksToBounds=YES;
///不改变所有权
self.view.layer.contents= (__bridge id )([UIImage imageNamed:@"1"].CGImage) ;
UIView *v = [UIView new];
[self.view addSubview:v];
v.backgroundColor=[UIColor redColor];
v.frame=CGRectMake(0, 0, 100, 100);
}) ;
}
//一般都是把一个任务放到一个串行的queue中，如果这个任务被拆分了，被放置到多个串行的queue中，但实际还是需要这个任务同步执行，那么就会有问题，因为多个串行queue之间是并行的。
//那该如何是好呢？
//
//这是就可以使用dispatch_set_target_queue了。
//
//如果将多个串行的queue使用dispatch_set_target_queue指定到了同一目标，那么着多个串行queue在目标queue上就是同步执行的，不再是并行执行。
//总结：dispatch_set_target_queue可以设置queue的优先级，也可以使多个serial queue在目标queue上一次只有一个执行
////最多支持64个线程并行执行
////多个线程并发时保持串行执行， 也可以使多个serial queue在目标queue上一次只有一个执行
////切换到目标线程执行代码
+(void)testTargetQueue {
dispatch_queue_t targetQueue = dispatch_queue_create("test.target.queue", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t queue1 = dispatch_queue_create("test.1", DISPATCH_QUEUE_SERIAL);
// dispatch_queue_t queue2 = dispatch_queue_create("test.2", DISPATCH_QUEUE_SERIAL);
// dispatch_queue_t queue3 = dispatch_queue_create("test.3", DISPATCH_QUEUE_SERIAL);
// dispatch_queue_t queue4 = dispatch_queue_create("test.4", DISPATCH_QUEUE_SERIAL);
// dispatch_queue_t queue5 = dispatch_queue_create("test.5", DISPATCH_QUEUE_SERIAL);
// dispatch_queue_t queue6 = dispatch_queue_create("test.6", DISPATCH_QUEUE_SERIAL);
// dispatch_queue_t queue7 = dispatch_queue_create("test.7", DISPATCH_QUEUE_SERIAL);
// dispatch_queue_t queue8 = dispatch_queue_create("test.8", DISPATCH_QUEUE_SERIAL);
//
// dispatch_set_target_queue(queue1, targetQueue);
// dispatch_set_target_queue(queue2, targetQueue);
// dispatch_set_target_queue(queue3, targetQueue);
// dispatch_set_target_queue(queue4, targetQueue);
// dispatch_set_target_queue(queue5, targetQueue);
// dispatch_set_target_queue(queue6, targetQueue);
// dispatch_set_target_queue(queue7, targetQueue);
// dispatch_set_target_queue(queue8, targetQueue);
void (^aa)(NSString*s) =^(NSString*S){
dispatch_async(queue1, ^{
NSLog(@"%@ in",S);
[NSThread sleepForTimeInterval:3.f];
NSLog(@"%@ out",S);
});
};
aa(@"1");
aa(@"2");
aa(@"3");
aa(@"4");
aa(@"5");
aa(@"6");
aa(@"7");
aa(@"8");
aa(@"9");
//
// dispatch_async(queue1, ^{
// NSLog(@"1 in");
// [NSThread sleepForTimeInterval:3.f];
// NSLog(@"1 out");
// });
// dispatch_async(queue1, ^{
// NSLog(@"1 in");
// [NSThread sleepForTimeInterval:3.f];
// NSLog(@"1 out");
// });
// dispatch_async(queue2, ^{
// NSLog(@"2 in");
// [NSThread sleepForTimeInterval:3.f];
// NSLog(@"2 out");
// });
// dispatch_async(queue3, ^{
// NSLog(@"3 in");
// [NSThread sleepForTimeInterval:1.f];
// NSLog(@"3 out");
// });
// dispatch_async(queue4, ^{
// NSLog(@"4 in");
// [NSThread sleepForTimeInterval:3.f];
// NSLog(@"4 out");
// });
// dispatch_async(queue5, ^{
// NSLog(@"5 in");
// [NSThread sleepForTimeInterval:3.f];
// NSLog(@"5 out");
// });
// dispatch_async(queue6, ^{
// NSLog(@"6 in");
// [NSThread sleepForTimeInterval:3.f];
// NSLog(@"6 out");
// });
// dispatch_async(queue7, ^{
// NSLog(@"7 in");
// [NSThread sleepForTimeInterval:3.f];
// NSLog(@"7 out");
// });
// dispatch_async(queue8, ^{
// NSLog(@"8 in");
// [NSThread sleepForTimeInterval:3.f];
// NSLog(@"8 out");
// });
NSLog(@"asdfa");
}
