美文网首页
iOS多线程之GCD

iOS多线程之GCD

作者: 芝麻酱的简书 | 来源:发表于2019-01-15 19:00 被阅读13次

    GCD(Grand Central Dispatch)是基于C语言开发的一套多线程开发机制

    1.GCD的优势：

    • GCD 可用于多核的并行运算
    • GCD 会自动利用更多的 CPU 内核（比如双核、四核）
    • GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
    • 程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码

    2. GCD 任务和队列：

    任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在 GCD 中是放在 block 中的。

    执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。

    • 同步执行（sync）：
      • 同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行。
      • 只能在当前线程中执行任务，不具备开启新线程的能力。
    • 异步执行（async）：
      • 异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
      • 可以在新的线程中执行任务，具备开启新线程的能力。

    队列（Dispatch Queue）：这里的队列指执行任务的等待队列，即用来存放任务的队列。队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。

    在 GCD 中有两种队列：串行队列和并行队列。两者都符合 FIFO（先进先出）的原则。两者的主要区别是：执行顺序不同，以及开启线程数不同。

    • 串行队列（Serial Dispatch Queue）：
      • 每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）
    • 并行队列（Concurrent Dispatch Queue）：
      • 可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）

    注意：并行队列的并行功能只有在异步（dispatch_async）函数下才有效

    主队列同步执行死锁原因：

    - (void)viewDidLoad {
    [super viewDidLoad];
    
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"123");
    });
}
解释：主队列中的viewDidLoad和block依据先进先出的顺序进行，
     viewDidLoad的完成需要block的执行，
     block的执行又需要等待viewDidLoad的执行完成，相互等待，造成死锁

    3.GCD常用方法

    3.1栅栏方法：dispatch_barrier_async

    如果我们需要执行两组异步动作，且第二组需要在第一组全部完成以后才开始，这样我们就需要用到dispatch_barrier_async在两个操作组间形成栅栏。

    dispatch_barrier_async函数会等待前边追加到并行队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。然后在dispatch_barrier_async函数追加的任务执行完毕之后，异步队列才恢复为一般动作，接着追加任务到该异步队列并开始执行

    # 下面代码会先并发执行任务1、2，均执行完后再执行barrier任务
# 待barrier任务执行完毕， 会接着并发执行3、4

- (void)barrier {
    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        // 追加任务1
    });
    dispatch_async(queue, ^{
        // 追加任务2
    });
    dispatch_barrier_async(queue, ^{
        //  barrier任务
    });
    dispatch_async(queue, ^{
        // 追加任务3
    });
    dispatch_async(queue, ^{
        // 追加任务4
    });
}
    栅栏dispatch_barrier_async的使用场景：

    1). 解决网络请求依赖，比如一个接口的请求需要依赖于另一个网络请求的结果
    2). 解决多读单写，要求：

    • 读者之间并发
    • 读者、写着之间互斥
    • 写者之间互斥
    // 声明一个队列
@property (nonatomic, strong) dispatch_queue_t concurrent_t;
// 创建并行队列
self.concurrent_t = dispatch_queue_create("com.zmj", DISPATCH_QUEUE_CONCURRENT);

#objectForKey方法: 采用同步方式，可以保证立刻得到返回值；
#                  提交到并发队列，可以保证并发执行多个读取操作。

- (id)objectForKey:(NSString *)key {
    __block id obj = nil;
    // 同步读取指定数据
    dispatch_sync(self.concurrent_t, ^{
        obj = [self.dic objectForKey: key];
    });
    return obj;
}

#setObject forKey方法: 采用GCD栅栏,保证写与写之间互斥
#同时写的栅栏隔离了读取操作，保证了读与写之间互斥

- (void)setObject:(id)obj forKey:(NSString *)key {
    // 异步栅栏 设置数据
    dispatch_barrier_async(self.concurrent_t, ^{
        [self.dic setObject: obj forKey: key];
    });
}
    3.2dispatch_after延迟执行

    dispatch_after函数并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到队列中。
    这个时间并不是绝对准确的。

     dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3*NSEC_PER_SEC);
 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
 dispatch_after(time, queue, ^{
        NSLog(@"3秒后添加到队列");
 });

#注意：相比于GCD方式，performSelector:withObject:afterDelay:有可能不会被调用到
比如：
 dispatch_queue_t t = dispatch_queue_create("这是并发队列", DISPATCH_QUEUE_CONCURRENT);
 dispatch_async(t, ^{
    //这个selector不会执行，因为线程中没有runloop,只有主线程会默认创建runloop
    [self performSelector:@selector(testDelay) withObject:nil afterDelay:3];
    // 解决方法：开启当前线程的runloop  
    //  [[NSRunLoop currentRunLoop] run];
 });
    3.3dispatch_once只执行一次

    dispatch_once():函数能保证某段代码在程序运行过程中只被执行1次，重复调用也没办法重复执行（单例模式中常用此方法）并且即使在多线程的环境下，dispatch_once也可以保证线程安全。

    - (void)once {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // 只执行1次的代码(这里面默认是线程安全的)
    });
}
    3.4dispatch_apply重复执行

    dispatch_apply按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。

    如果是在串行队列中使用dispatch_apply，那么就和 for 循环一样，按顺序同步执行。

    为了不阻塞线程可以使用并发队列dispatch_async来达到异步执行的目的。

    还有一点，无论是在串行队列，还是并行队列中，dispatch_apply都会等待全部任务执行完毕，这点就像是同步操作，也像是队列组中的 dispatch_group_wait方法。

    //生成全局队列
 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
   
# 该函数按指定的次数将指定的Block追加到指定的Dispatch Queue中,并等到全部的处理执行结束
# @param 10    指定重复次数  指定10次
# @param queue 追加对象的Dispatch Queue
# @param index 带有参数的Block, index的作用是为了按执行的顺序区分各个Block

 NSLog(@"begin");

 dispatch_apply(10, queue, ^(size_t index) {
      NSLog(@"%zd",index);
 });

 NSLog(@"end");
    3.5 GCD 队列组：dispatch_group
    3.5.1 队列组之dispatch_group_notify

    监听 group 中任务的完成状态，当所有的任务都执行完成后，追加任务到 group 中，并执行任务。

     dispatch_queue_t disqueue =  dispatch_queue_create("myQueue", DISPATCH_QUEUE_CONCURRENT);
 dispatch_group_t disgroup = dispatch_group_create();

 dispatch_group_async(disgroup, disqueue, ^{
        NSLog(@"1");
 });
    
 dispatch_group_async(disgroup, disqueue, ^{
         NSLog(@"2");
 });
    
 dispatch_group_notify(disgroup, disqueue, ^{
     NSLog(@"notify");
 });
    
# 打印顺序： 1、2、notify
    3.5.2 队列组之dispatch_group_wait

    暂停当前线程（阻塞当前线程），等待指定的 group 中的任务执行完成后，才会往下继续执行。

    - (void)groupWait {
    NSLog(@"begin");
    
    dispatch_group_t group =  dispatch_group_create();
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务1
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务2
    });
    
    // 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    NSLog(@"end");
}
# 打印顺序： 1、2顺序不定，因为是并发执行，end在最后
    3.5.3 队列组之dispatch_group_enter和dispatch_group_leave
    • dispatch_group_enter 标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数+1
    • dispatch_group_leave 标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数-1。
    • 当 group 中未执行完毕任务数为0的时候，才会使dispatch_group_wait解除阻塞，以及执行追加到dispatch_group_notify中的任务。
    - (void)groupEnterAndLeave { 
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_group_enter(group);

    dispatch_async(queue, ^{
        // 追加任务1

        dispatch_group_leave(group);
    });
    
    dispatch_group_enter(group);

    dispatch_async(queue, ^{
        // 追加任务2

        dispatch_group_leave(group);
    });

 // 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

    NSLog(@"wait_end");
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的异步操作都执行完毕后，回到主线程.
        NSLog(@"notify_end");
    });
}
# 打印顺序：任务1、2顺序不定，然后wait_end, 最后notify_end

    这里的dispatch_group_enter、dispatch_group_leave组合，其实等同于前面的dispatch_group_async。

    3.6dispatch_semaphore信号量

    GCD 中的信号量是指 Dispatch Semaphore，是持有计数的信号。

    在 Dispatch Semaphore 中，计数为0时等待，不可通过；计数为1或大于1时，计数减1且不等待，可通过。

    • dispatch_semaphore_create：创建一个Semaphore并初始化信号的总量

    • dispatch_semaphore_signal：发送一个信号，让信号总量加1

    • dispatch_semaphore_wait：可以使总信号量减1，当信号总量为0时就会一直等待（阻塞所在线程），否则就可以正常执行。

    Dispatch Semaphore 在实际开发中主要用于：

    • 保持线程同步，将异步执行任务转换为同步执行任务
    • 保证线程安全，为线程加锁
    3.6.1 Semaphore保持线程同步

    我们在开发中，会遇到这样的需求：异步执行耗时任务，并使用异步执行的结果进行一些额外的操作。换句话说，相当于，将将异步执行任务转换为同步执行任务。

     - (void)semaphoreSync {
    NSLog(@"semaphore---begin");
    
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    
    __block int number = 0;
    dispatch_async(queue, ^{
       // 追加任务1 模拟耗时操作
       number = 100;
       dispatch_semaphore_signal(semaphore);
    });
    
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"semaphore---end");
}
    3.6.2 Semaphore线程安全

    场景：总共有50张火车票，有两个售卖火车票的窗口，一个是北京火车票售卖窗口，另一个是上海火车票售卖窗口。两个窗口同时售卖火车票，卖完为止。

    - (void)initTicketStatusSave {
    NSLog(@"semaphore---begin");
    
    semaphoreLock = dispatch_semaphore_create(1);
    
    self.ticketSurplusCount = 50;
    
    // queue1 代表北京火车票售卖窗口
    dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL);
    // queue2 代表上海火车票售卖窗口
    dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL);
    
    __weak typeof(self) weakSelf = self;
    dispatch_async(queue1, ^{
        [weakSelf saleTicketSafe];
    });
    
    dispatch_async(queue2, ^{
        [weakSelf saleTicketSafe];
    });
}

// 售卖火车票(线程安全)
- (void)saleTicketSafe {
    while (1) {
        // 相当于加锁
        dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);
        
        if (self.ticketSurplusCount > 0) {  //如果还有票，继续售卖
            self.ticketSurplusCount--;
             // 相当于解锁
            dispatch_semaphore_signal(semaphoreLock);
        } else { //如果已卖完，关闭售票窗口
            // 相当于解锁
            dispatch_semaphore_signal(semaphoreLock);
            break;
        }
    }
}

    GCD常见面试题

    下面代码会死锁吗，如果不会执行顺序是？

    - (void)test {
    dispatch_queue_t global_t =  dispatch_get_global_queue(0, DISPATCH_QUEUE_PRIORITY_DEFAULT);
    NSLog(@"1");
    dispatch_sync(global_t, ^{
        NSLog(@"2");
        
        dispatch_sync(global_t, ^{
            NSLog(@"3");
        });
        
        NSLog(@"4");
    });
    NSLog(@"5");
}

    答案：
    1.只要是以同步方式提交任务，不论是串行还是并发，都是在当前线程（多是主线程）执行
    2.提交到全局（并发）队列的任务，全局（并发）队列可以并发执行任务，所以不会跟上面一样造成死锁

    附录：http://www.cocoachina.com/ios/20161031/17887.html

    相关文章

      网友评论

          本文标题：iOS多线程之GCD

          本文链接：https://www.haomeiwen.com/subject/cmwydqtx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|iOS多线程之GCD|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！