iOS多线程-GCD使用总结

写在前面:

GCD，它是基于C语言的API，开发者只需要将任务放在block内，并指定好追加的队列，就可以完成多线程开发。属于系统级的线程管理，在Dispatch queue中执行需要执行的任务性能非常的高。以下为个人的学习笔记，大神略过！

队列

队列：Dispatch Queue是执行处理的等待队列，按照任务（block）追加到队列里的顺序，并遵循FIFO执行处理

• 队列分为串行队列和并行队列。
  • Serial Dispatch Queue：串行队列，等待当前执行任务处理结束的队列。

    - (void)gcd_serialQueue
    {
     //第一个函数为队列的名称，
    // 第二个参数是NULL和DISPATCH_QUEUE_SERIAL时，返回的队列就是串行队列。
       dispatch_queue_t queue = dispatch_queue_create("serial queue", NULL);
        for (NSInteger i = 0; i < 10; i ++) {
            dispatch_async(queue, ^{
               NSLog(@"serial queue :%ld",i);
           });
       }
   }   
  

  输出:

   Study_GCD[46280:2496418] serial queue :0
   Study_GCD[46280:2496418] serial queue :1
   Study_GCD[46280:2496418] serial queue :2
   Study_GCD[46280:2496418] serial queue :3
   Study_GCD[46280:2496418] serial queue :4
   Study_GCD[46280:2496418] serial queue :5
   Study_GCD[46280:2496418] serial queue :6
   Study_GCD[46280:2496418] serial queue :7
   Study_GCD[46280:2496418] serial queue :8
   Study_GCD[46280:2496418] serial queue :9
  

  • Concurrent Dispatch Queue:并发队列，不等待当前执行任务处理结束的队列。

    - (void)gcd_concurrentQueue
    {
       dispatch_queue_t queue = dispatch_queue_create("concurrent queue", DISPATCH_QUEUE_CONCURRENT);
        for (NSInteger i = 0; i < 6; i ++) {
          dispatch_async(queue, ^{
           NSLog(@"concurrent queue %ld ",i);
           });
       }
    }
  

输出:

     Study_GCD[46343:2501196] concurrent queue 0 
     Study_GCD[46343:2501197] concurrent queue 3 
     Study_GCD[46343:2501215] concurrent queue 2 
     Study_GCD[46343:2501214] concurrent queue 1 
     Study_GCD[46343:2501199] concurrent queue 4 
     Study_GCD[46343:2501217] concurrent queue 5 

• 放入串行队列的任务将会在主线程执行，执行顺序是按照顺序执行。
• 放入并行队列的任务会在子线程执行，执行顺序是并行执行。

主线程&子线程

主线程：负责执行UI活动，绝大部分的UI活动都要在这里调用，不能让其阻塞，要将耗时的任务放到子线程来做。
子线程：负责执行耗时的运算，网络请求等不能放在主线程的任务。

系统为我们提供了共用的主队列(Main Dispatch Queue)和全局并行队列(Global Dispatch Queue)。我们只需将需要执行的任务放入到这两类队列里就可以实现多线程编程。

系统提供的队列

Main Dispatch Queue

• 主队列：
  放在这个队列里的任务会追加到主线程的RunLoop中执行。需要刷新UI的时候我们可以直接获取这个队列，将任务追加到这个队列中。

dispatch_queue_t mainQ = dispatch_get_main_queue();
NSOperationQueue *mainQ = [NSOperationQueue mainQueue];

• 获取主队列并布置任务

//NSThread
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(nullable id)arg waitUntilDone:(BOOL)wait;

//GCD
 dispatch_async(dispatch_get_main_queue(), ^{                   

                        [doSomething];

                    });

Globle Dispatch Queue

• 全局并发队列：
  开发者可以不需要特意通过dispatch_queue_create方法创建一个Concurrent Dispatch Queue，可以将任务直接放在这个全局并发队列里面。

dispatch queue_t globalDispatchQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);

• 获取全局并行队列并布置任务

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

          [doSomething];
 });

线程通讯

很多情况下，我们需要在子线程进行下载任务，下载完成后在主线程更新UI，这时候就需要线程之间的通信：

 dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

              //下载图片
              NSData *dataFromURL = [NSData dataWithContentsOfURL:imageURL];
              UIImage *imageFromData = [UIImage imageWithData:dataFromURL];

      dispatch_async(dispatch_get_main_queue(), ^{

              //加载完成更新view
              UIImageView *imageView = [[UIImageView alloc] initWithImage:imageFromData];

      });

  });
//在这里，我们在全局并行队列的回调block里调用了主线程，并在主线程里执行了UI操作。

dispatch_group

需求点：执行多个耗时的异步任务，但是只能等到这些任务都执行完毕后，才能在主线程执行某个任务。

为了实现这个需求，我们需要让将这些异步执行的操作放在

• dispatch_group_async函数中执行，最后再调用，
• dispatch_group_notify来执行最后执行的任务。

 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), ^{
      // 执行1个耗时的异步操作
  });

  dispatch_group_notify(group, dispatch_get_main_queue(), ^{
      // 等前面的异步操作都执行完毕后，回到主线程...
  });

dispatch_after

• 在某个线程里，在指定的时间后处理某个任务：

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    NSLog(@"2秒之后追加到队列");
});

dispatch_barrier_async

• 关于解决数据竞争的方法：读取处理是可以并发的，但是写入处理却是不允许并发执行的。
• 读取处理追加到concurrent dispatch queue中
• 写入处理在任何一个读取处理没有执行的状态下，追加到serial dispatch queue中（也就是说，在写入处理结束之前，读取处理不可执行）。

需求点：虽然我们有时要执行几个不同的异步任务，但是我们还是要将其分成两组：当第一组异步任务都执行完成后才执行第二组的异步任务。这里的组可以包含一个任务，也可以包含多个任务。

为了实现这个需求，我们需要使用dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);在两组任务之间形成“栅栏”，使其“下方”的异步任务在其“上方”的异步任务都完成之前是无法执行的。

 dispatch_queue_t queue = dispatch_queue_create("1122333", DISPATCH_QUEUE_CONCURRENT);

    dispatch_async(queue, ^{
        NSLog(@"----任务 1-----");
    });

    dispatch_async(queue, ^{
        NSLog(@"----任务 2-----");
    });    

    dispatch_barrier_async(queue, ^{
        NSLog(@"----barrier-----");
    });

    dispatch_async(queue, ^{
        NSLog(@"----任务 3-----");
    });

    dispatch_async(queue, ^{
        NSLog(@"----任务 4-----");
    });

输出

Study_GCD[46399:2506252] ----任务 2-----
Study_GCD[46399:2506249] ----任务 1-----
Study_GCD[46399:2506249] ----barrier-----
Study_GCD[46399:2506249] ----任务 3-----
Study_GCD[46399:2506252] ----任务 4-----

dispatch_sync

• dispatch_async：异步函数，这个函数会立即返回，不做任何等待，它所指定的block“非同步地”追加到指定的队列中。
• dispatch_sync：同步函数，这个函数不会立即返回，它会一直等待追加到特定队列中的制定block完成工作后才返回，所以它的目的（也是效果）是阻塞当前线程。(开发中切记注意!)

dispatch_once (一次性任务)

• 通过dispatch_once处理的代码只执行一次，而且是线程安全的：

- (void)gcd_dispatch_once_1
{
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    for (NSInteger index = 0; index < 5; index++) {
        
        dispatch_async(queue, ^{
            [self gcd_onceCode];
        });
    }
}


- (void)gcd_onceCode
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"只执行一次的代码");
    });
}

输出:

Study_GCD[46436:2509090] 只执行一次的代码

参考内容：

http://libdispatch.macosforge.org