iOS开发之多线程技术——GCD篇

                #pragma mark
#pragma mark - 同步方法
/**
 同步的打印顺序
 打印 begin
 打印 [NSThread currentThread]
 打印 end
 */
- (void)syncTask {
    
    NSLog(@"begin");
    
    // 1.GCD同步方法/**
     参数1：队列 第一个参数0其实为队列优先级DISPATCH_QUEUE_PRIORITY_DEFAULT，如果要适配 iOS 7.0 & 8.0，则始终为0
     参数2：任务
     */
    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        // 任务中要执行的代码
        NSLog(@"%@", [NSThread currentThread]);
        
    });
    
    NSLog(@"end");
    
}

                #pragma mark
#pragma mark - 异步方法
/**
 异步的打印顺序
 打印 begin
 打印 一般情况下为end，极少数情况下会很快开辟完新的线程，先打印出[NSThread currentThread]
 */
- (void)asyncTask {
    
    /**
     异步：不会在“当前线程”执行，会首先去开辟新的子线程，开辟线程需要花费时间
     */
    
    NSLog(@"begin");
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"%@", [NSThread currentThread]);
    });
    
    NSLog(@"end");
    
}

                #pragma mark
#pragma mark - 串行队列同步方法
/**
 串行队列，同步方法
 1.打印顺序 : 从上到下，依次打印，因为是串行的
 2.在哪条线程上执行 : 主线程，因为是同步方法，所以在当前线程里面执行，恰好当前线程是主线程，所以它就在主线程上面执行
 
 应用场景：开发中很少用
 */
- (void)serialSync {
    // 1.创建一个串行队列/**
     参数1:队列的表示符号，一般是公司的域名倒写
     参数2:队列的类型
         DISPATCH_QUEUE_SERIAL 串行队列
         DISPATCH_QUEUE_CONCURRENT 并发队列
     */
    dispatch_queue_t serialQuene = dispatch_queue_create("com.baidu", DISPATCH_QUEUE_SERIAL);
    
    // 创建任务void (^task1) () = ^() {
        NSLog(@"task1---%@", [NSThread currentThread]);
    };
    
    void (^task2) () = ^() {
        NSLog(@"task2---%@", [NSThread currentThread]);
    };
    
    void (^task3) () = ^() {
        NSLog(@"task3---%@", [NSThread currentThread]);
    };
    
    // 添加任务到队列,同步方法执行    dispatch_sync(serialQuene, task1);
    dispatch_sync(serialQuene, task2);
    dispatch_sync(serialQuene, task3);
}

                #pragma mark
#pragma mark - 串行队列异步方法
/**
 串行队列，异步方法
 1.打印顺序：从上到下，依次执行，它是串行队列
 2.在哪条线程上执行：在子线程，因为它是异步执行，异步就是不在当前线程里面执行
 
 应用场景：耗时间，有顺序的任务
    1.登录--->2.付费--->3.才能看
 
 */
- (void)serialAsync {
    // 除了第三步，和串行同步方法中都是一样的
    // 1.创建一个串行队列
    dispatch_queue_t serialQuene = dispatch_queue_create("com.baidu", DISPATCH_QUEUE_SERIAL);
    
    // 2.创建任务void (^task1)() = ^() {
        NSLog(@"task1---%@", [NSThread currentThread]);
    };
    void (^task2)() = ^() {
        NSLog(@"task2---%@", [NSThread currentThread]);
    };
    void (^task3)() = ^() {
        NSLog(@"task3---%@", [NSThread currentThread]);
    };
    
    // 3.添加任务到队列    dispatch_async(serialQuene, task1);
    dispatch_async(serialQuene, task2);
    dispatch_async(serialQuene, task3);
}

                #pragma mark
#pragma mark - 并发队列同步任务
/**
 并发队列，同步任务
 1.打印顺序：因为是同步,所以依次执行
 2.在哪条线程上执行：主线程，因为它是同步方法，它就在当前线程里面执行，也就是在主线程里面依次执行
 
 当并发队列遇到同步的时候还是依次执行，所以说方法(同步/异步)的优先级会比队列的优先级高
 
 * 只要是同步方法，都只会在当前线程里面执行，不会开子线程
 
 应用场景：
    开发中几乎不用
 
 */
- (void)serialSync {
    
    /**
     参数1:队列的表示符号，一般是公司的域名倒写
     参数2:队列的类型
     DISPATCH_QUEUE_SERIAL 串行队列
     DISPATCH_QUEUE_CONCURRENT 并发队列
     */// 1.创建并发队列
    dispatch_queue_t serialSync = dispatch_queue_create("com.xiaojukeji", DISPATCH_QUEUE_CONCURRENT);
    
    // 2.创建任务void (^task1)() = ^() {
        NSLog(@"task1---%@", [NSThread currentThread]);
    };
    
    void (^task2)() = ^() {
        NSLog(@"task2---%@", [NSThread currentThread]);
    };
    
    void (^task3)() = ^() {
        NSLog(@"task3---%@", [NSThread currentThread]);
    };
    
    // 3.添加任务到并发队列    dispatch_sync(serialSync, task1);
    dispatch_sync(serialSync, task2);
    dispatch_sync(serialSync, task3);
}

                #pragma mark
#pragma mark - 并发队列异步任务
/**
 1.打印顺序：无序的
 2.在哪条线程上执行：在子线程上执行，每一个任务都在它自己的线程上执行
        可以创建N条子线程，它是由底层可调度线程池来决定的，可调度线程池它是有一个重用机制
 
 应用场景
    同时下载多个影片
 */
- (void)serialAsync {
    // 1.创建并发队列
    dispatch_queue_t serialAsync = dispatch_queue_create("com.xiaojukeji", DISPATCH_QUEUE_CONCURRENT);
    
    // 2.创建任务void (^task1)() = ^() {
        NSLog(@"task1---%@", [NSThread currentThread]);
    };
    
    void (^task2)() = ^() {
        NSLog(@"task2---%@", [NSThread currentThread]);
    };
    
    void (^task3)() = ^() {
        NSLog(@"task3---%@", [NSThread currentThread]);
    };
    
    // 3.将任务添加到并发队列    dispatch_async(serialAsync, task1);
    dispatch_async(serialAsync, task2);
    dispatch_async(serialAsync, task3);
}

                #pragma mark
#pragma mark - 全局队列同步任务
/**
 全局队列，同步任务
 1.打印顺序：依次执行，因为它是同步的
 2.在哪条线程上执行:主线程，因为它是同步方法，它就在当前线程里面执行
 
 当它遇到同步的时候，并发队列还是依次执行，所以说，方法的优先级比队列的优先级高
 
 * 只要是同步方法，都只会在当前线程里面执行，不会开子线程
 
 应用场景：开发中几乎不用
 */
- (void)globalSync {
    /**
     参数1：
        IOS7:表示的优先级
        IOS8:服务质量
        为了保证兼容IOS7&IOS8一般传入0
     
     参数2:未来使用，传入0
     */
    
    NSLog(@"begin");
    // 1.创建全局队列
    dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);
    
    // 2.创建任务void (^task1)() = ^() {
        NSLog(@"task1----%@", [NSThread currentThread]);
    };
    
    void (^task2)() = ^() {
        NSLog(@"task2----%@", [NSThread currentThread]);
    };
    
    void (^task3)() = ^() {
        NSLog(@"task3----%@", [NSThread currentThread]);
    };
    
    // 3.添加任务到全局队列    dispatch_sync(globalQueue, task1);
    dispatch_sync(globalQueue, task2);
    dispatch_sync(globalQueue, task3);

    NSLog(@"end");
}

                #pragma mark
#pragma mark - 全局队列异步任务
/**
 全局队列，异步方法
 1.打印顺序:无序的
 2.在子线程上执行，每一个任务都在它自己的线程上执行，线程数由底层可调度线程池来决定的，可调度线程池有一个重用机制
 应用场景：
    蜻蜓FM同时下载多个声音
 */
- (void)globalAsync {
    
    NSLog(@"begin");
    
    dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);
    
    void (^task1)() = ^() {
        NSLog(@"task1---%@", [NSThread currentThread]);
    };
    
    void (^task2)() = ^() {
        NSLog(@"task2---%@", [NSThread currentThread]);
    };
    
    void (^task3)() = ^() {
        NSLog(@"task3---%@", [NSThread currentThread]);
    };
    
    dispatch_async(globalQueue, task1);
    dispatch_async(globalQueue, task2);
    dispatch_async(globalQueue, task3);
    
    NSLog(@"end");
    
}

                #pragma mark
#pragma mark - 主队列异步任务
/**
 主队列，异步任务
 1.执行顺序:依次执行，因为它在主线程里面执行
 * 似乎与我们的异步任务有所冲突，但是因为它是主队列，所以，只在主线程里面执行
 
 2.是否会开线程：不会，因为它在主线程里面执行
 
 应用场景：
    当做了耗时操作之后，我们需要回到主线程更新UI的时候，就非它不可
 */
- (void)mainAsync {
    
    NSLog(@"begin");
    
    // 1.创建主队列
    dispatch_queue_t mainAsync = dispatch_get_main_queue();
    
    // 2.创建任务void (^task1)() = ^() {
        NSLog(@"task1---%@", [NSThread currentThread]);
    };
    
    void (^task2)() = ^() {
        NSLog(@"task2---%@", [NSThread currentThread]);
    };
    
    void (^task3)() = ^() {
        NSLog(@"task3---%@", [NSThread currentThread]);
    };

    dispatch_async(mainAsync, task1);
    dispatch_async(mainAsync, task2);
    dispatch_async(mainAsync, task3);
    
    NSLog(@"end");
    
}

                #pragma mark
#pragma mark - 主队列同步方法有问题，不能用是个奇葩，会造成死锁
/**
 主队列，同步任务有问题，不能用，彼此都在等对方是否执行完了，所以是互相死等
 主队列只有在主线程空闲的时候，才会去调度它里面的任务去执行
 */
- (void)mainSync {
    
    NSLog(@"begin");
    // 1.创建主队列
    dispatch_queue_t mainSync = dispatch_get_main_queue();
    
    // 2.创建任务void (^task1)() = ^() {
        NSLog(@"task1---%@", [NSThread currentThread]);
    };
    
    void (^task2)() = ^() {
        NSLog(@"task2---%@", [NSThread currentThread]);
    };
    
    void (^task3)() = ^() {
        NSLog(@"task3---%@", [NSThread currentThread]);
    };
    
    // 3.添加任务到主队列中    dispatch_sync(mainSync, task1);
    dispatch_sync(mainSync, task2);
    dispatch_sync(mainSync, task3);
    
    NSLog(@"end");
}

                #pragma mark
#pragma mark - 模拟登录下载多个电影数据
/**
 同步的作用：保证我们任务执行的先后顺序
 1.登录
 
 2.同时下载三部电影
 */
- (void)loadManyMovie {
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        
        NSLog(@"%@", [NSThread currentThread]);
        // 1.登录，同步在当前线程里面工作
        dispatch_sync(dispatch_get_global_queue(0, 0), ^{
            
            NSLog(@"登录了---%@", [NSThread currentThread]);
            sleep(3);
            
        });
        
        // 2.同时下载三部电影()
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            NSLog(@"正在下载第一个电影---%@", [NSThread currentThread]);
        });
        
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            NSLog(@"正在下载第二个电影---%@", [NSThread currentThread]);
        });
        
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            NSLog(@"正在下载第三个电影---%@", [NSThread currentThread]);
        });
        
        dispatch_sync(dispatch_get_main_queue(), ^{
            [NSThread sleepForTimeInterval:1.0];
            NSLog(@"计算机将在三秒后关闭---%@", [NSThread currentThread]);
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"关机了---%@", [NSThread currentThread]);
            });
        });
        
    });
    
}

                //
                 MARK: - 延迟执行
- (void)delay {
    /**
     从现在开始，经过多少纳秒，由"队列"调度异步执行 block 中的代码

     参数
     1. when    从现在开始，经过多少纳秒
     2. queue   队列
     3. block   异步执行的任务
     */
    dispatch_time_t when = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC));
    void (^task)() = ^ {
        NSLog(@"%@", [NSThread currentThread]);
    };
    // 主队列
//    dispatch_after(when, dispatch_get_main_queue(), task);
    // 全局队列
//    dispatch_after(when, dispatch_get_global_queue(0, 0), task);
    // 串行队列
    dispatch_after(when, dispatch_queue_create("itheima", NULL), task);

    NSLog(@"come here");
}

- (void)after {
    [self.view performSelector:@selector(setBackgroundColor:) withObject:[UIColor orangeColor] afterDelay:1.0];

    NSLog(@"come here");
}

                //
                 使用 dispatch_once 实现单例
+ (instancetype)sharedSingleton {
    staticid instance;

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [[self alloc] init];
    });

    return instance;
}

                #pragma mark
#pragma mark - 调度组
/**
 调度组的实现原理:类似引用计数器进行+1和-1的操作
 应用场景
 比如同时开了三个线程下载视频，只有当三个视频完全下载完毕后，我才能做后续的事
 这个就需要用到调度组，这个调度组，就能监听它里面的任务是否都执行完毕
 */
- (void)groupDispatch {
    
    // 1.创建调度组
    dispatch_group_t group = dispatch_group_create();
    
    // 2.获取全局队列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    // 3.创建三个下载任务void (^task1) () = ^(){
        NSLog(@"%@----下载片头",[NSThread currentThread]);
    };
    
    dispatch_group_enter(group); // 引用计数+1void (^task2) () = ^(){
        NSLog(@"%@----下载中间的内容",[NSThread currentThread]);
        
        [NSThread sleepForTimeInterval:3.0];
        
        NSLog(@"--下载中间内容完毕---");
        dispatch_group_leave(group); // 引用计数-1    };
    
    dispatch_group_enter(group); // 引用计数+1void (^task3) () = ^(){
        NSLog(@"%@----下载片尾",[NSThread currentThread]);
        dispatch_group_leave(group); // 引用计数-1    };
    
    // 4.需要将我们的队列 和 任务，加入到组内去监控    dispatch_group_async(group, queue, task1);
    dispatch_group_async(group, queue, task2);
    dispatch_group_async(group, queue, task3);
    
    // 5.监听的函数/**
     远离：来监听当调度组的引用计数器为0时，才会执行该函数中内容,否则不会执行
     参数1：组
     参数2：决定了参数3在哪个线程里面执行
     参数3：组内完全下载完毕后需要执行的代码
     */
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 表示组内的所有内容全部下载完成后会来到这里
        NSLog(@"把下好的视频按照顺序拼接好，然后显示在UI去播放%@", [NSThread currentThread]);
    });
    
}