IOS 多线程之GCD使用

GCD

简介

• Grand Central Dispatch(GCD) 是 Apple 开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并发任务。在 Mac OS X 10.6 雪豹中首次推出，也可在 iOS 4 及以上版本使用。
• GCD是一个替代诸如NSThread等技术的很高效和强大的技术。GCD完全可以处理诸如数据锁定和资源泄漏等复杂的异步编程问题。GCD的工作原理是让一个程序，根据可用的处理资源，安排他们在任何可用的处理器核心上平行排队执行特定的任务。这个任务可以是一个功能或者一个程序段。
• GCD仍然在一个很低的水平使用线程，但是它不需要程序员关注太多的细节。GCD创建的队列是轻量级的，苹果声明一个GCD的工作单元需要由15个指令组成。也就是说创造一个传统的线程很容易的就会需要几百条指令。
• GCD中的一个任务可被用于创造一个被放置于队列的工作项目或者事件源。如果一个任务被分配到一个事件源，那么一个由功能或者程序块组成的工作单元会被放置于一个适当的队列中。苹果公司认为GCD相比于普通的一个接一个的执行任务的方式更为有效率。

优势

• 是苹果公司为多核的并行运算提出的解决方案。
• 会自动利用更多的CPU内核（比如双核、四核）。
• 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）。
• 程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码。

一、基本概念

• 串行：按顺序执行，每次只有一个任务被执行。
• 并行：无序执行，同一时间可以有多个任务被执行。
• 同步：会阻塞当前线程，完成代码块后才继续执行后续代码。只能在当前线程中执行任务，不具备开启新线程的能力。

• 异步：不会阻塞当前线程，无需等待继续执行后续代码。可以在新的线程中执行任务，具备开启新线程的能力。

  
  
  image.png
  
  
  image.png

二、基本使用

1、主队列和全局队列

1.1、主队列

• 专门用来在主线程上调度任务的队列
  不会开启线程
  如果当前主线程正在有任务执行，那么无论主队列中当前被添加了什么任务，都不会被调度
  dispatch_get_main_queue();

1.2、全局队列

• 为了方便程序员的使用，苹果提供了全局队列 dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
  全局队列是一个并发队列
  在使用多线程开发时，如果对队列没有特殊需求，在执行异步任务时，可以直接使用全局队列

2、混合使用

2.1、串行+同步

    //创建串行队列
    dispatch_queue_t queue_serial = dispatch_queue_create("com.test.queue_serial", DISPATCH_QUEUE_SERIAL);
    
    NSLog(@"队列创建完成");
    dispatch_sync(queue_serial, ^{
        NSLog(@"1");
    });
    NSLog(@"2");

输出结果

• 由此可知，任务会阻塞了当前线程，执行完队列中的任务后才继续执行。

2.2、串行+异步

    //创建串行队列
    dispatch_queue_t queue_serial = dispatch_queue_create("com.test.queue_serial", DISPATCH_QUEUE_SERIAL);
    
    NSLog(@"队列创建完成");
    dispatch_async(queue_serial, ^{
        NSLog(@"1");
    });
    NSLog(@"2");

输出结果

• 由此可知，任务不会阻塞了当前线程，后续代码可以继续执行。

2.3、串行+同步+异步

2.3.1、混搭情况一

    //创建串行队列
    dispatch_queue_t queue_serial = dispatch_queue_create("com.test.queue_serial", DISPATCH_QUEUE_SERIAL);
    
    NSLog(@"队列创建完成");
    dispatch_sync(queue_serial, ^{
        NSLog(@"1");
        dispatch_async(queue_serial, ^{
            NSLog(@"2");
        });
    });
    NSLog(@"3");

输出结果

• 由于第一个是dispatch_sync为同步，阻塞了当前线程，所以1会先输出，而第二个是dispatch_async为异步，不阻塞当前线程，所以接着输出3，最后输出2。

2.3.1、混搭情况二（此种情况会奔溃，请注意）

    //创建串行队列
    dispatch_queue_t queue_serial = dispatch_queue_create("com.test.queue_serial", DISPATCH_QUEUE_SERIAL);
    
    NSLog(@"队列创建完成");
    dispatch_async(queue_serial, ^{
        NSLog(@"1");
        dispatch_sync(queue_serial, ^{
            NSLog(@"2");
        });
        NSLog(@"4");
    });
    NSLog(@"3");

奔溃图

image.png

• 由于第一个是dispatch_async为异步，不阻塞当前线程，所以3先输出，接着输出1，然后奔溃了。奔溃的原因是，此时的队列是串行队列，必须等待任务一完成后才能执行任务二，但是里面又是dispatch_sync同步开启的，所有就造成任务一等待任务二完成，任务二等待任务一完成，互相等待，死锁。

2.4、并行+同步

    //创建并行队列
    dispatch_queue_t queue_concurrent = dispatch_queue_create("com.test.queue_serial", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"队列创建完成");
    dispatch_sync(queue_concurrent, ^{
        NSLog(@"1");
    });
    NSLog(@"2");

输出结果

• 由此可知，任务会阻塞了当前线程，执行完队列中的任务后才继续执行。

2.4、并行+异步

    //创建并行队列
    dispatch_queue_t queue_concurrent = dispatch_queue_create("com.test.queue_concurrent", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"队列创建完成");
    dispatch_async(queue_concurrent, ^{
        NSLog(@"1");
    });
    NSLog(@"2");

输出结果

• 由此可知，任务不会阻塞了当前线程，后续代码可以继续执行。

2.5、并行+同步+异步

2.5.1、混搭情况一

    //创建并行队列
    dispatch_queue_t queue_concurrent = dispatch_queue_create("com.test.queue_concurrent", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"队列创建完成");
    dispatch_async(queue_concurrent, ^{
        NSLog(@"1");
        dispatch_sync(queue_concurrent, ^{
            NSLog(@"2");
        });
        NSLog(@"4");
    });
    NSLog(@"3");

输出结果

• 由于第一个是dispatch_async为异步，不阻塞当前线程，所以3会先输出，接着输出1，然后第二个是dispatch_sync为同步，阻塞当前线程，所以接着输出2，最后输出4。

2.5.1、混搭情况二

    //创建并行队列
    dispatch_queue_t queue_concurrent = dispatch_queue_create("com.test.queue_concurrent", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"队列创建完成");
    dispatch_sync(queue_concurrent, ^{
        NSLog(@"1");
        dispatch_async(queue_concurrent, ^{
            NSLog(@"2");
        });
        NSLog(@"4");
        
    });
    NSLog(@"3");

image.png

• 由于第一个是dispatch_sync为同步，阻塞当前线程，所以1会先输出，而第二个是dispatch_async为异步，不阻塞当前线程，所以接着输出4，然后输出2，最后输出3。先输出2的原因是当前队列是并行队列，只要当前有空闲的线程就会先调度。

3、其它队列与主队列通讯

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"耗时操作");
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"更新UI");
        })
    })

三、深入一点点使用

1、延时执行

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 5秒后在主队列中执行
        NSLog(@"%@",[NSThread currentThread]);
    });

2、只执行一次（多用于单例）

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // 只执行1次的代码(默认是线程安全的)
    });

3、快速遍历

    NSArray *array = @[@"value1",@"value2",@"value3",@"value4",@"value5",@"value6"];
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_apply([array count], queue, ^(size_t index) {
        NSLog(@"%zu------%@",index, [array objectAtIndex:index]);
    });

快速遍历

4、栅栏函数

• 最直接的作用: 控制任务执行顺序,同步。
• dispatch_barrier_async 前面的任务执行完毕才会来到这里。
• dispatch_barrier_sync 作用相同,但是这个会堵塞线程,影响后面的任务执行。
• 非常重要的两点:
  1、栅栏函数只能控制同一并发队列。
  2、必须是自己创建的并发队列，不能使用系统的全局队列（dispatch_get_global_queue）。
• 使用

    //创建并行队列
    dispatch_queue_t queue = dispatch_queue_create("com.test.queue_barrier", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"1-->%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"2-->%@", [NSThread currentThread]);
    });
    
    dispatch_barrier_async(queue, ^{
        NSLog(@"barrier-->%@", [NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"3-->%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"4-->%@", [NSThread currentThread]);
    });

输出结果

• 栅栏前后的多个任务执行顺序是没有固定的，但肯定的是1和2执行完才会执行3和4。

5、调度组

• 最直接的作用：控制任务执行顺序。
• 常用函数：
  dispatch_group_create 创建组
  dispatch_group_async 进组任务
  dispatch_group_notify 进组任务执行完毕通知
  dispatch_group_wait 进组任务执行等待时间
  dispatch_group_enter 进组
  dispatch_group_leave 出组
  PS：进组和出租注意要搭配使用
• 使用

-(void) gcdGroupTest
{
    dispatch_group_t group =  dispatch_group_create();
    //获取全局并行队列
    dispatch_queue_t queue_concurrent = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_group_async(group, queue_concurrent, ^{
        NSLog(@"耗时操作1");
    });
    
    dispatch_group_async(group, queue_concurrent, ^{
        NSLog(@"耗时操作2");
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等任务都执行完毕后，回到主线程
        NSLog(@"任务组任务完成后-->%@",[NSThread currentThread]);
    });
    dispatch_group_async(group, queue_concurrent, ^{
        NSLog(@"耗时操作3");
    });
    dispatch_group_async(group, queue_concurrent, ^{
        NSLog(@"耗时操作4");
    });
}

-(void) gcdGroupTest2
{
       dispatch_group_t group =  dispatch_group_create();
    //获取全局并行队列
    dispatch_queue_t queue_concurrent = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(group);
    dispatch_async(queue_concurrent, ^{
        NSLog(@"耗时操作1");
        dispatch_group_leave(group);
    });
    dispatch_group_enter(group);
    dispatch_async(queue_concurrent, ^{
        NSLog(@"耗时操作2");
        dispatch_group_leave(group);
    });
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等任务都执行完毕后，回到主线程
        NSLog(@"任务组任务完成后-->%@",[NSThread currentThread]);
    });
    dispatch_group_enter(group);
    dispatch_async(queue_concurrent, ^{
        NSLog(@"耗时操作3");
        dispatch_group_leave(group);
    });
    dispatch_group_enter(group);
    dispatch_async(queue_concurrent, ^{
        NSLog(@"耗时操作4");
        dispatch_group_leave(group);
    });

}

image.png

• 由此可知，任务组的任务全部完成之后，才会通知主线程。