iOSgcd队列

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");
    
}