GCD—代码演练

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event {
    [self gcdDemo9];
}

#pragma mark - 全局队列
// MARK: 全局队列（本质上就是并发队列）
//
- (void)gcdDemo9 {
    /**
     参数
     1. 涉及到系统适配
        iOS 8       服务质量（让线程响应的更快还是更慢）
         - QOS_CLASS_USER_INTERACTIVE           用户交互(用户迫切希望线程快点被执行，不要用耗时的操作)
         - QOS_CLASS_USER_INITIATED             用户需要的(同样不要使用耗时操作)
         - QOS_CLASS_DEFAULT                    默认的(给系统用来重置队列的)
         ** QOS_CLASS_UTILITY                    实用工具(用来做耗时操作)
         - QOS_CLASS_BACKGROUND                 后台
         - QOS_CLASS_UNSPECIFIED                没有指定优先级
     
        iOS 7       调度的优先级
         － DISPATCH_QUEUE_PRIORITY_HIGH 2       高优先级
         － DISPATCH_QUEUE_PRIORITY_DEFAULT 0    默认优先级
         － DISPATCH_QUEUE_PRIORITY_LOW (-2)     低优先级
         － DISPATCH_QUEUE_PRIORITY_BACKGROUND   后台优先级
     
     提示：尤其不要选择 BACKGROUND 优先级和服务质量，用户不需要知道线程什么时候执行完成！线程的执行会慢的令人发指！
     
     有关服务质量的介绍，用在与 XPC 框架结合使用的，XPC 用在 MAC 平台上做进程间通讯的框架！
     
     因为大家工作后，暂时会考虑 iOS7 & iOS8 的适配，无法使用服务质量，直接指定 0，能够做到 iOS7 & 8 的适配
     dispatch_get_global_queue(0, 0);
     
     2. 为未来使用保留的，应该始终传入0
     */
    dispatch_queue_t q = dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0);
    
    for (int i = 0; i < 10; i++) {
        dispatch_async(q, ^{
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
    NSLog(@"com here");
}

#pragma mark - 同步任务
// MARK: "增强版"同步任务
- (void)gcdDemo8 {
    // 队列
    dispatch_queue_t q = dispatch_queue_create("itcast", DISPATCH_QUEUE_CONCURRENT);
    
    // 任务，一组预先准备好的块代码，在需要的时候执行！
    void (^task)() = ^ {
        // 1. 用户登录，必须要第一个执行
        dispatch_sync(q, ^{
            NSLog(@"用户登录 %@", [NSThread currentThread]);
        });
        // 2. 扣费
        dispatch_async(q, ^{
            NSLog(@"扣费 %@", [NSThread currentThread]);
        });
        // 3. 下载
        dispatch_async(q, ^{
            NSLog(@"下载 %@", [NSThread currentThread]);
        });
    };
    
    dispatch_async(q, task);
}

// MARK: 同步任务的作用！
/**
 在网络开发中，通常会把很多任务放在后台异步执行，有的时候，有些任务会彼此有"依赖"关系！
 
 例子：小说的网站，用户登录，扣费，下载小说 A，扣费，下载小说 B...
 
 利用同步任务，能够做到，任务依赖关系，前一个同步任务不执行完，队列就不会调度后面的任务！
 
 come here 在用户登录后面！
 */
- (void)gcdDemo7 {

    dispatch_queue_t q = dispatch_queue_create("itcast", DISPATCH_QUEUE_CONCURRENT);
    
    // 1. 用户登录，必须要第一个执行
    dispatch_sync(q, ^{
        NSLog(@"用户登录 %@", [NSThread currentThread]);
    });
    // 2. 扣费
    dispatch_async(q, ^{
        NSLog(@"扣费 %@", [NSThread currentThread]);
    });
    // 3. 下载
    dispatch_async(q, ^{
        NSLog(@"下载 %@", [NSThread currentThread]);
    });
    
    NSLog(@"come here");
}

#pragma mark - 主队列
// MARK: 主队列，同步执行
/**
 主队列：不开线程
 同步任务：不开线程
 
 猜测：come here??? ｜ 卡死
 */
- (void)gcdDemo6 {
    dispatch_queue_t q = dispatch_get_main_queue();
    
    NSLog(@"卡死了吗？");
    
    dispatch_sync(q, ^{
        NSLog(@"我来了");
    });
    
    NSLog(@"come here");
}

// MARK: 主队列，异步执行
/**
 队列：主队列，不可能在其他线程执行
 任务：异步，开线程，不会阻塞线程执行，不用等待着一条语句执行完，就能执行下一句
 
 猜测：不开线程，顺序执行，come here 出现在最后！！！！！
 */
- (void)gcdDemo5 {
    // 1. 主队列 － 程序启动之后已经存在主线程，主队列同样存在
    dispatch_queue_t q = dispatch_get_main_queue();
    
    // 2. 安排一个任务
    for (int i = 0; i<10; i++) {
        dispatch_async(q, ^{
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
    
    NSLog(@"睡会");
    [NSThread sleepForTimeInterval:2.0];
    NSLog(@"come here");
}

#pragma mark - gcd 队列 & 执行任务的方法
// MARK: 并发队列，同步执行
/**
 队列：并发队列，可以调度多个任务
 同步：不能开线程
 
 问题：会开几条线程？顺序执行吗？come here？
 猜测：不会，会，最后
 效果：和串行队列，同步执行效果一样！
 */
- (void)gcdDemo4 {
    // 1. 队列
    dispatch_queue_t q = dispatch_queue_create("itcast", DISPATCH_QUEUE_CONCURRENT);
    
    // 2. 异步执行
    for (int i = 0; i<10; i++) {
        dispatch_sync(q, ^{
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
    NSLog(@"come here");
}

// MARK: 并发队列，异步执行
/**
 队列：并发队列，可以调度多个任务
 异步：可以开启线程
 
 问题：会开几条线程？顺序执行吗？come here？
 猜测：会，不会，不是最后
 */
- (void)gcdDemo3 {
    // 1. 队列
    dispatch_queue_t q = dispatch_queue_create("itcast", DISPATCH_QUEUE_CONCURRENT);
    
    // 2. 异步执行
    for (int i = 0; i<10; i++) {
        dispatch_async(q, ^{
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
    NSLog(@"come here");
}

// MARK: 串行队列，异步执行
/**
 串行队列，一个一个调度任务
 执行的方法：异步，会开线程

 问题：会开几条线程？顺序执行吗？come here?
 猜测：不确定，会/不会顺序执行，一上来就执行
 答案：只会开一条线程：是因为队列是按照先进先出的顺序调度任务，因此有一个线程就足够了
      顺序执行，FIFO
 */
- (void)gcdDemo2 {
    dispatch_queue_t q = dispatch_queue_create("itcast", NULL);
    
    for (int i = 0; i<10; i++) {
//        NSLog(@"%d------", i);
        
        dispatch_async(q, ^{
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
    NSLog(@"come here");
}

// MARK: 串行队列，同步执行
/**
 不会开线程，会顺序执行
 */
- (void)gcdDemo1 {
    // 1. 队列
    /**
     参数
     1. 队列的名称
     2. 队列的属性 
        DISPATCH_QUEUE_SERIAL(NULL) 表示串行
     */
//    dispatch_queue_t q = dispatch_queue_create("itcast", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t q = dispatch_queue_create("itcast", NULL);
    
    // 2. 执行任务
    for (int i = 0; i<10; i++) {
        dispatch_sync(q, ^{
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }

}