只需知道如何开线程、会看相关的第三方框架即可。

简介

-

两个核心概念

任务：执行什么操作
队列：用来存放任务

队列类型：

• 并发队列（Concurrent Dispatch Queue）
  可以让多个任务并发执行（自动开启多个线程同时执行任务）
  在异步dispatch_async函数下才有效

• 串行队列（Serial Dispatch Queue）
  让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个）
  按照FIFO顺序执行。

任务派发：

• 同步
  指阻塞当前线程，既要等待添加的耗时任务块Block完成后，函数才能返回，后面的代码才能继续执行。
• 异步
  指将任务添加到队列后，函数立即返回，后面的代码不用等待添加的任务完成即可马上执行。异步提交无法确定任务执行顺序。

GCD多线程经常会使用 同步函数dispatch_sync、异步函数dispatch_async，向指定队列 添加任务。

分辨

-

各种队列的执行效果

-

主队列（一种串行队列）

凡是放到主队列中的任务，都必须在主线程中执行。

1.异步函数+主队列

串行执行，所有任务都在主线程中执行，不会开线程

2.同步函数+主队列————》会死锁！一般不用。

主队列的特点：如果主队列发现当前主线程有任务在执行，那么它会暂停队列中的任务，直到主线程空闲为止。

GCD实现线程间通信

说明：在更新UI时回到了主线程（通过新设一个同步/异步函数，队列参数为主队列）

• 开子线程做异步任务

    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        //...做一些任务
        
        dispatch_sync(dispatch_get_main_queue(), ^{
            //回到主线程，更新UI
        });
    });

举例，开启子线程下载图片

   //1.获取一个 全局串行队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
  
   __weak typeof(self) weakSelf = self;
   //2.把任务添加到队列中执行
    dispatch_async(queue, ^{
        NSURL *url = [NSURL URLWithString:_imgString];
        NSData *imageData = [NSData dataWithContentsOfURL:url];
        UIImage * bgImage = [UIImage imageWithData:imageData];
        bgImage = [bgImage applyLightEffectAtFrame:CGRectMake(0, 0, bgImage.size.width, bgImage.size.height)];
        //3.回到主线程
        dispatch_async(dispatch_get_main_queue(), ^{
            weakSelf.backImageView.image = bgImage;
        });
    });

GCD常用函数

• 延迟执行

int64_t delayInSeconds = 10.0;      // 延迟的时间

dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, delayInSeconds * NSEC_PER_SEC);
dispatch_after(popTime, dispatch_get_main_queue(), ^(void){           
     // do something  ...  ... 
});

或

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)( 10.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // ...     
});

• 一次性代码
  这个应用程序只执行一次，不再执行

    static dispatch_once_t onceToken;
    
    dispatch_once(&onceToken, ^{
        //...
    });

不能应用于懒加载。应用于单例模式。

• 栅栏函数
  用于控制异步函数的执行顺序，只有执行完栅栏函数，才能执行后面的队列任务。使用时，必须自己创建队列，不能使用全局并发队列。

同步函数没有必要用栅栏函数。

• 快速迭代（遍历）
  内部会开子线程和主线程一起完成遍历任务，异步执行任务

• 主线程异步任务

    dispatch_async(dispatch_get_main_queue(), ^{
    
    });

• 栅栏函数
  用于控制异步函数的执行顺序。可避免数据竞争。使用时，必须自己创建队列，不能使用全局并发队列。

    //创建队列
    dispatch_queue_t queue = dispatch_queue_create("download", DISPATCH_QUEUE_CONCURRENT);
    
    //异步函数
    dispatch_async(queue, ^{
        
        //....异步任务1
    });
    
    dispatch_async(queue, ^{
        
        //....异步任务2
    });
    
    //栅栏函数
    dispatch_barrier_async(queue, ^{
        
        //...
    });

一个dispatch barrier允许在一个并发队列中创建一个同步点。当在并发队列中遇到一个barrier， 他会延迟执行barrier的block，等待所有在barrier之前提交的blocks执行结束。 这时，barrier block自己开始执行。 之后， 队列继续正常的执行操作。

• 队列组
  某几个队列的任务都完成后，再执行其他任务

    //创建队列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    /创建队列组
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_async(group, queue, ^{
        //...异步任务1
    });
    dispatch_group_async(group, queue, ^{
        //...异步任务2
    });
    dispatch_group_async(group, queue, ^{
        //...异步任务3
    });
    
    //  拦截通知，当队列组里的任务都完成了，会进入下面这个方法
    dispatch_group_notify(group, queue, ^{
        //... ... 
    });

如，加载多个图片

// 使用Dispatch Group追加block到Global Group Queue,这些block如果全部执行完毕，
就会执行Main Dispatch Queue中的结束处理的block。
// 创建队列组
dispatch_group_t group = dispatch_group_create();
// 获取全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_async(group, queue, ^{ /*加载图片1 */ });
dispatch_group_async(group, queue, ^{ /*加载图片2 */ });
dispatch_group_async(group, queue, ^{ /*加载图片3 */ }); 
// 当并发队列组中的任务执行完毕后才会执行这里的代码
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 合并图片
});

• 定时任务

    /* 在指定线程上定义计时器 */
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_source_t _timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
    
    /* 开始的时间 */
    dispatch_time_t when = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC));
    /* 设置计时器 ，时间间隔 5s  */
    dispatch_source_set_timer(_timer, when, 5.0 * NSEC_PER_SEC, 0);
    /* 计时器回调block */
    dispatch_source_set_event_handler(_timer, ^{
        // do  something
        NSLog(@"需要做的任务!");
        
    });
    /* 开启计时器 */
    dispatch_resume(_timer);

    self.timer = _timer;   // 强引用计时器对象（必须）

必须销毁self.timer才能终止定时任务：self.timer = nil ;

GCD取消线程

可以取消还未执行的线程。但是没办法做到取消一个正在执行的线程。

• 取消函数 dispatch_block_cancel

dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
dispatch_block_t block1 = dispatch_block_create(0, ^{
    NSLog(@"block1");
});
dispatch_block_t block2 = dispatch_block_create(0, ^{
    NSLog(@"block2");
});
dispatch_block_t block3 = dispatch_block_create(0, ^{
    NSLog(@"block3");
});
    
dispatch_async(queue, block1);
dispatch_async(queue, block2);
dispatch_async(queue, block3);

dispatch_block_cancel(block3);   // 取消 block3

投机取巧：使用临时变量 + return 方式取消 正在执行的Block。

__block BOOL gcdFlag = NO; // 临时变量
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    for (long i=0; i<1000; i++) {
        NSLog(@"正在执行第i次:%ld",i);
        sleep(0.1);
        if (gcdFlag==YES) { // 判断并终止
            NSLog(@"终止");
            return ;
        }
    };
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    NSLog(@"我要停止啦");
    gcdFlag = YES;
});