GCD 小总结

简介：GCD是对多线程、多核开发较完整的封装。在使用GCD的时候，系统会自动根据CPU使用情况进行调度，所以GCD是一个简单易用，但是效果很好的多线程多核开发工具。

概念

同步：在当前线程不开启新的线程,任务顺序执行，同步操作添加任务后等待任务执行
异步：在当前线程开启新的线程(主线程除外)，任务执行可以不按顺序执行（串行队列顺序执行，并发队列异步执行),异步操作添加任务后立即返回
串行：任务执行按照顺序
并发：任务执行可以异步执行（具体顺序结合对应的任务操作类型async/sync）

串行队列/并发队列

  • Dispatch Queue按照追加的顺序（先进先出FIFO，First-In-First-Out）执行处理。
  • Queue(队列)：分为串行队列和并行队列，所谓的串行和并行是指任务的执行顺序。
    串行队列上添加A、B、C、D四个任务，任务的执行顺序必然也是A、B、C、D的顺序。
    并发队列上添加A、B、C、D四个任务，sync(同步)操作任务顺序执行；async(异步)操作任务异步执行。
  • Dispatch Queue 队列几种创建方式
    //获得主线程的dispatch队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    //获得程序进程缺省产生的并发队列，可设定优先级来选择高、中、低三个优先级队列。
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //生成一个串行队列，队列中的block按照先进先出（FIFO）的顺序去执行，实际上为单线程执行
    dispatch_queue_t queue = dispatch_queue_create("com.dispatch.serial", DISPATCH_QUEUE_SERIAL);
    //生成一个并发执行队列，block被分发到多个线程去执行
    dispatch_queue_t queue = dispatch_queue_create("com.dispatch.concurrent", DISPATCH_QUEUE_CONCURRENT);

同步、异步、串行、并发

同步异步代表任务添加的时候会不会立即返回，任务执行的时候会不会开辟新的线程。串行和并发代表任务执行的方式。
同步串行和并发，任务的执行方式是一样的。没有区别，因为没有开辟新的线程，所有的任务都在一条线程中执行。
异步串行和异步并发，任务执行的方式是有区别的，异步主队列不会开辟线程，但是任务依然是异步执行，主线程执行完当前线程的所有任务后，才会去执行异步添加的任务；异步串行会开辟一条新的线程，队列中所有任务按照添加的顺序一个一个执行；异步并发会开辟多条线程，至于具体开辟多少条线程，是由系统决定的，但是所有的任务好像就是同时执行的一样。

GCD-同步函数／异步函数

  • sync(同步)函数
    提交任务后等待任务执行完毕，会阻塞当前线程
dispatch_sync(queue, ^{
　　//block具体代码
});
同步执行block，函数不返回，一直等到block执行完毕。编译器会根据实际情况优化代码，
所以有时候你会发现block其实还在当前线程上执行，并没用产生新线程。
  • async(异步)函数
    提交任务后会立即返回，不会阻塞当前线程
dispatch_async(queue, ^{
　　//block具体代码
}); //异步执行block，函数立即返回
同步执行block，函数不返回，一直等到block执行完毕。编译器会根据实际情况优化代码，
所以有时候你会发现block其实还在当前线程上执行，并没用产生新线程。
  • sync同步／async异步操作注意点
    实际编程经验告诉我们，尽可能避免使用dispatch_sync，嵌套使用时还容易引起程序死锁。
    串形队列的同步嵌套造成循环的任务等待，造成死锁
dispatch_sync(queue1, ^{
      dispatch_sync(queue1, ^{
　　　　......
　　});
　　......
　});

不妨思考下，为什么下面代码在主线程中执行会死锁：

dispatch_sync(dispatch_get_main_queue(), ^{
　　......
}); 
是否会死锁，实质是分析对应的代码操作是否存在相互等待的操作
特点是：同步操作内部嵌套/存在一个同步的操作，并且这两个同步操作所在的对列是同一个串行的队列，
并且这两个同步操作之间不存在异步操作嵌套（主线程默认就是一个就串行同步的队列）

那实际运用中，一般可以用dispatch这样来写，常见的网络请求数据多线程执行模型：

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
　　//子线程中开始网络请求数据
　　//更新数据模型
　　dispatch_sync(dispatch_get_main_queue(), ^{
　　　　//在主线程中更新UI代码
　　});
});
//程序的后台运行和UI更新代码紧凑，代码逻辑一目了然。

sync/async + queue(几种搭配)

  • sync(同步) + queue （主队列／自定义串行队列／并发队列）

sync + 主队列

 dispatch_sync(dispatch_get_main_queue(), ^{
       //do something ...
 });
//主线程被阻塞，任务不会被执行。。。

sync + 自定义串行队列

dispatch_queue_t serialQueue = dispatch_queue_create("com.dispatch.serial", DISPATCH_QUEUE_SERIAL);
for (NSInteger j=0 ; j<10; j++) {
     dispatch_sync(serialQueue, ^{
     //do something ...
    });
 }
//当前线程上顺序(串行)执行任务，不会创建新的线程,任务添加时刻便开始执行

sync + 并发队列

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_sync(globalQueue, ^{
        // do something ...
});
//在当前线程中顺序（串行）执行，没有创建新的线程，任务添加时刻便开始执行
  • async(异步) + queue （主队列／自定义串行队列／并发队列）

async + 主队列

   dispatch_async(mainQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"1");
    });
    dispatch_async(mainQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"2");
    });
    dispatch_async(mainQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"3");
    });
    dispatch_async(mainQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"4");
    });
    dispatch_async(mainQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"5");
    });
    dispatch_async(mainQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"6");
    });
    NSLog(@"end");
1.异步任务在主队列上，没有开辟新的线程，任务依然是保持队形的。
2.是异步的但是又没有产生新的线程，这个和之前的异步不太一样，需要留意。
3.dispatch_async方法，往主队列添加了一个异步任务，此时并不阻塞主线程，
主线程立刻返回执行后面的任务。主线程当前的任务完成了，然后从主队列取出下一个任务（刚刚添加的异步任务）来执行
输出

async + 自定义串行队列

    dispatch_async(serialQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"1");
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"2");
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"3");
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"4");
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"5");
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"6");
    });
//开辟一个新的线程，线程中任务顺序(串行)执行

输出

async + 并发队列

 dispatch_async(globalQueue, ^{
            //  taskA
    });
dispatch_async(globalQueue, ^{
            // taskB
dispatch_async(globalQueue, ^{
            // taskC
    });

//会开辟多条线程执行任务，线程数量由系统决定，线程开始和结束的时间都是随机的

GCD常用函数

1.GCD延迟函数

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // 5秒后异步执行
});

2.GCD栅栏函数
场景：任务都是异步执行的，但是执行的任务分为2组，第一组异步执行完后开始执行第二组任务
注意：栅栏函数不能使用全局并发队列，需要自己创建队列（使用全局并发队列后发现栅栏函数不起作用了）

- (void)GCDAction:(id)sender {
    //dispatch_queue_t queue =  dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("queuelll", DISPATCH_QUEUE_CONCURRENT);
    // 异步执行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：2   %@",[NSThread currentThread]);
        }
    });
    
    dispatch_barrier_async(queue, ^{
        NSLog(@"End barrier:%@", [NSThread currentThread]);
        NSLog(@"******* 并发执行，但是34一定在12后面 *********");
    });
    
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：3   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"栅栏：4   %@",[NSThread currentThread]);
        }
    });
}

3.GCD dispatch_once函数

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    NSLog(@"once");
});

4.GCD队列组 dispatch_group_notify函数
场景：异步几个结束后回到主线程

    dispatch_group_t group =  dispatch_group_create();
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"队列组：A);
    });
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"队列组：B！");
    });
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"队列组：回到主线程");
    });

总结

GCD中任务执行顺序和线程开启情况受操作方式和队列类型2个因素影响

  • 👉1线程开启情况
    同步sync操作不开启线程；异步操作async开启线程（主队列除外），串行队列开启一条线程(当前代码上下文)，异步队列开启至少一条线程(当前代码上下文)，数量由系统决定

思考：异步操作并发队列中线程的开启数量由系统判断（当前代码上下文至少开启一条线程）
如下代码：代码中仅仅一句nslog的有无就可能决定是否多开启一条线程

    //如下代码：开启一条线程
    dispatch_queue_t Queue2 = dispatch_queue_create("yflConss", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(Queue2, ^{
        NSLog(@"A%@",[NSThread currentThread]);
        dispatch_async(Queue2, ^{
            NSLog(@"B%@",[NSThread currentThread]);
        });
//        NSLog(@"JJ");
    });

    //如下代码：开启2条线程
    dispatch_queue_t Queue2 = dispatch_queue_create("yflConss", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(Queue2, ^{
        NSLog(@"A%@",[NSThread currentThread]);
        dispatch_async(Queue2, ^{
            NSLog(@"B%@",[NSThread currentThread]);
        });
        NSLog(@"JJ");
    });

    //开启2条线程
    dispatch_queue_t Queue2 = dispatch_queue_create("yflConss", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(Queue2, ^{
        NSLog(@"A%@",[NSThread currentThread]);
    });
    dispatch_async(Queue2, ^{
        NSLog(@"B%@",[NSThread currentThread]);
    });

👉2任务执行顺序
串行队列顺序执行，并发队列在同步操作sync中顺序执行，在异步操作async中异步执行

  • 线程是否开始和操作类型有关，任务执行顺序由操作类型和队列类型2个因素有关（同步操作都是顺序执行；串行队列都是顺序执行；只有异步并发队列才是异步执行）
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容