GCD的深入研究

本文是接上一篇文章《iOS——多线程理解》https://www.jianshu.com/p/81cc15d5ae3d，要从GCD中收获更多，首先要明白几个概念：

• 队列：队列是一种特殊的线性表，只能在前端（front）进行删除操作，只能在后端（rear）进行删除操作，它的特性是先进先出。

• 串行队列：Serial Dispatch Queue，一次只调度一个任务，队列中的任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）。

• 并发队列：Concurrent Dispatch Queue,并发队列可以让多个任务并发（同时）执行，它会自动开启多个线程同时执行任务，并发功能只有在异步函数下才会有效。并发队列下执行同步函数不会创建新线程。global queue也是一个并发队列。

• 同步：只是在当前线程中执行任务，不具备开启新线程的能力。

• 异步：可以在新的线程中执行任务，具备开启新线程的能力。

• main queue：通过dispatch_get_main_queue()获得，这是一个与主线程相关的串行队列。

• global queue：全局队列是并发队列，由整个进程共享。存在着高、中、低三种优先级的全局队列。调用dispath_get_global_queue并传入优先级来访问队列。

• 创建队列的方法：
  创建一个队列：dispatch_queue_t q = dispatch_queue_create(const char *label, dispatch_queue_attr_t attr)
  参数：
  const char *label：队列的名称
  dispatch_queue_attr_t attr：队列的属性，属性有两个，分别为：
  DISPATCH_QUEUE_SERIAL(NULL) 串行队列
  DISPATCH_QUEUE_CONCURRENT 并发队列
  队列属性为宏，其中串行队列的宏值为NULL，所以创建一个串行队列可以传NULL作为第二个参数。

接下来，咱们来看看GCD中的几种情况：

第一种：同步串行队列

-(void)syncSerial{
    NSLog(@"begin");
    dispatch_queue_t queue = dispatch_queue_create("com.tzjy.-02--GCD", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(queue, ^{
        NSLog(@"1%@",[NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"2%@",[NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"3%@",[NSThread currentThread]);
    });
    NSLog(@"end");
  }

打印结果如下：

image.png

结论：串行队列，任务依次执行，dispatch_sync同步任务不会新开子线程，会在阻塞当前线程，直到block代码块执行完毕，会继续执行串行队列里剩下的任务。

第二种：异步串行队列

-(void)asyncSerial{
    NSLog(@"begin");
    dispatch_queue_t queue = dispatch_queue_create("async_serial", DISPATCH_QUEUE_SERIAL);
    dispatch_async(queue, ^{
        NSLog(@"1%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"2%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"3%@",[NSThread currentThread]);
    });
    NSLog(@"end");
}

运行结果：

image.png

结论：串行队列里面的任务1，2，3依次执行，由于是异步创建的，所以新开了一条线程，同时不阻塞主线程，所以主线程的begin和end先打印了。

第三种：串行队列异步嵌套同步

- (void)nestSerial{
    NSLog(@"begin");
    dispatch_queue_t queue = dispatch_queue_create("nest_serial", DISPATCH_QUEUE_SERIAL);
    dispatch_async(queue, ^{//block1
        NSLog(@"1");
        dispatch_sync(queue, ^{//block2
            NSLog(@"2");
        });
        NSLog(@"3");

    });
    NSLog(@"end");
}

运行结果：直接崩溃，原因两个任务相互等待，造成死锁。

image.png

结论：因为是串行队列，所以任务2要等待任务block1执行完成，即等待3打印，可是任务2又是同步任务，那么会阻塞当前线程，所以block1又得等待block2执行完成才能继续执行3，所以形成了相互等待，也就造成了死锁。为了避免造成线程死锁，一般都是用并发队列。

第四种：并发同步队列

-(void)syncConcurrent{
    NSLog(@"begin");
    dispatch_queue_t queue = dispatch_queue_create("syncConcurrent", DISPATCH_QUEUE_CONCURRENT);
    dispatch_sync(queue, ^{
        NSLog(@"1%@",[NSThread currentThread]);
        dispatch_sync(queue, ^{
            NSLog(@"2%@",[NSThread currentThread]);
        });
        NSLog(@"3%@",[NSThread currentThread]);
    });
    NSLog(@"end");
}

运行结果：

image.png

结论：因为是并发队列，所以各个任务之间是并发执行，不用等待，但是同步任务的创建，会阻塞当前线程，所以打印结果是依次执行，同步任务不会新开子线程，所以一直是在主线程。

第五种：并发异步队列

-(void)asyncConcurrent{
    NSLog(@"begin");
    dispatch_queue_t queue = dispatch_queue_create("asyncConcurrent", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"1%@",[NSThread currentThread]);
        dispatch_async(queue, ^{
            NSLog(@"2%@",[NSThread currentThread]);
        });
        NSLog(@"3%@",[NSThread currentThread]);
    });
    NSLog(@"end");
}

运行结果有两种：

image.png

结论：因为有两个异步任务，那么创建了两条子线程，同时是并发队列，所以任务没有先后顺序，因此2和3谁先谁后是不定的。虽然这种方式是最高效的，但是也有一个缺点，会创建许多子线程，就是比较耗费内存，耗费CPU性能。创建线程：占内存、CPU资源，子线程（512kb）main（1M）。当然这个时候咱们就得想到怎么控制线程并发数问题。

信号量机制控制线程并发数

    - (void)semaphore{
        dispatch_semaphore_t sema = dispatch_semaphore_create(10);
        for (int i = 0; i < 1000; i++) {
            dispatch_async(dispatch_get_global_queue(0, 0), ^{
                dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
                NSLog(@"%d %@",i,[NSThread currentThread]);
                dispatch_semaphore_signal(sema);
            });
        }
    }

结论：通过打印结果你会发现，我明明走了1000次异步，但是线程数却只有60多条，这就控制了线程的并发数。

GCD对于一些需求的实现

• 1、假设我们原先有4个任务要执行，我们现在要插入一个任务0，这个任务0要在1、2都并发执行完了之后才能执行，而3、4号任务要在这个任务0结束后才允许并发，这个时候就要用到栅栏barrier。

/**
 栅栏，假如队列为全局队列，栅栏将失效，将被看做一条普通的异步任务
 */
- (void)barrier{
//    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_queue_t queue = dispatch_queue_create("indetifer", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        sleep(2);
        NSLog(@"1");
    });
    dispatch_async(queue, ^{
        sleep(2);

        NSLog(@"2");
    });
    dispatch_barrier_async(queue, ^{
        NSLog(@"0");
    });
    dispatch_async(queue, ^{
        NSLog(@"3");
    });
    dispatch_async(queue, ^{
        NSLog(@"4");
    });
}

• 2、当我需要保证所有的耗时任务执行完成后再刷新界面。这个时候就要用到线程组

- (void)group{
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_enter(group);
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            sleep(2);
            NSLog(@"1");
            dispatch_group_leave(group);
        });
    });
    dispatch_group_enter(group);

    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            NSLog(@"2");
            dispatch_group_leave(group);

        });
    });
    dispatch_group_enter(group);

    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            NSLog(@"3");
            dispatch_group_leave(group);

        });
    });
    dispatch_group_notify(group, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"end");
    });
}

• 3、GCD代替for循环

- (void)apply{
    //将制定次数的block添加队列，index表示按执行顺序来区分block,等待所有任务结束
    dispatch_queue_t queue = dispatch_queue_create(NULL, DISPATCH_QUEUE_CONCURRENT);
    dispatch_apply(10, queue, ^(size_t index) {
        dispatch_async(queue, ^{
            NSLog(@"%zu",index);
        });
    });
    NSLog(@"end");
}

到此，我对GCD的理解就到此为止。感谢腾讯公开课的分享。