iOS多线程--GCD

838 阅读4分钟

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

简介

-

两个核心概念

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

队列类型:

  • 并发队列(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;
});