GCD 相关函数

作者: xiaofu666 | 来源:发表于2021-09-03 20:07 被阅读0次

GCD 相关函数
OC多线程学习（二） - GCD
ios多线程操作— GCD延迟操作和相关使用方法
iOS-GCD常用函数和栅栏函数
iOS底层探索之多线程(四)—GCD的队列
扩展GCD(求逆元,解同余方程等等)
iOS开发之多线程笔记(四)之GCD
GCD栅栏函数, 快速迭代和调度组的使用
GCD栅栏
iOS Objective-C GCD之函数篇

串行同步

    // 串行队列
    dispatch_queue_t queue = dispatch_queue_create("com.sf.test", DISPATCH_QUEUE_SERIAL);
    // 同步执行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步2 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步3 %@",[NSThread currentThread]);
        }
    });

串行异步

    // 串行队列
    dispatch_queue_t queue = dispatch_queue_create("com.sf.test", DISPATCH_QUEUE_SERIAL);
    // 异步执行
    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_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行异步3 %@",[NSThread currentThread]);
        }
    });

并行同步

    // 并行队列
    dispatch_queue_t queue = dispatch_queue_create("com.sf.test", DISPATCH_QUEUE_CONCURRENT);
    // 同步执行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并行同步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并行同步2 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并行同步3 %@",[NSThread currentThread]);
        }
    });

并行异步

    // 并行队列
    dispatch_queue_t queue = dispatch_queue_create("com.sf.test", DISPATCH_QUEUE_CONCURRENT);
    // 异步执行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并行异步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并行异步2 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并行异步3 %@",[NSThread currentThread]);
        }
    });

主队列同步 会死锁

    NSLog(@"\n\n**************主队列同步，放到主线程会死锁***************\n\n");
    // 主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    // 同步执行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主队列同步1 %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主队列同步2 %@",[NSThread currentThread]);
        }
    });

主队列异步

    NSLog(@"\n\n**************主队列异步，串行执行***************\n\n");
    // 主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    // 同步执行
    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]);
        }
    });

异步处理耗时，回主线程刷新UI

    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"异步处理耗时数据 %@",[NSThread currentThread]);
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"主线程刷新UI %@",[NSThread currentThread]);
        });
    });

栅栏函数

    dispatch_queue_t queue = dispatch_queue_create("com.sf.test", 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(@"\n\n**************barrier**************\n\n");
    });
    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]);
        }
    });

延时执行

    //相对时间
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 5.0 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
        NSLog(@"延迟5秒执行");
    });
    //绝对时间 (NUll表示自动获取当前时区的当前时间作为开始时刻)
    dispatch_after(dispatch_walltime(NULL, 5.0 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
        NSLog(@"延迟5秒执行");
    });

    //设置固定时间，可做定时任务
    NSDateFormatter *formatter = [NSDateFormatter new];
    formatter.dateFormat = @"yyyy-MM-dd HH:mm:ss";
    struct timespec time;
    time.tv_sec = (NSInteger)[[formatter dateFromString:@"2020-02-02 11:11:11"] timeIntervalSince1970];
    //比固定的时间点再晚10秒
    dispatch_time_t timer = dispatch_walltime(&time, 10*NSEC_PER_SEC);
    dispatch_after(timer, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{
        NSLog(@"2020-02-02 11:11:11 时间延迟10秒后执行");
    });

时间单位

#define NSEC_PER_SEC    1000000000ull     //每秒有1000000000纳秒
#define NSEC_PER_MSEC   1000000ull        //每毫秒有1000000纳秒
#define USEC_PER_SEC    1000000ull        //每秒有1000000微秒
#define NSEC_PER_USEC   1000ull           //每微秒有1000纳秒

1秒的写作方式可以是
1 * NSEC_PER_SEC;
1000 * NSEC_PER_MSEC;
USEC_PER_SEC * NSEC_PER_USEC

单例函数

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"程序只执行了一次");
    });

快速遍历

    //这个顺序是随机的，并发的
    dispatch_queue_t queue = dispatch_queue_create("com.sf.test", DISPATCH_QUEUE_CONCURRENT);
    dispatch_apply(10, queue, ^(size_t index) {
        NSLog(@"dispatch_apply : %zd---%@",index,[NSThread currentThread]);
    });

队列函数

    dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, dispatch_queue_create(0, 0), ^{
        NSLog(@"队列组1：一个耗时操作已完成！");
    });
    dispatch_group_async(group, dispatch_queue_create(0, 0), ^{
        NSLog(@"队列组2：一个耗时操作已完成！");
    });
    dispatch_group_async(group, dispatch_queue_create(0, 0), ^{
        NSLog(@"队列组3：一个耗时操作已完成！");
    });
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"队列组：前面的耗时操作都完成了，回到主线程");
    });

多网络请求完成模拟

    NSMutableURLRequest *request = [[NSMutableURLRequest alloc] init];
    [request setURL:[NSURL URLWithString:@"https://baidu.com"]];
    [request setTimeoutInterval:3];//超时时间
    [request setHTTPMethod:@"GET"];
    
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_group_async(group, queue, ^{
        dispatch_group_enter(group);
        NSURLSessionDataTask *task=[[NSURLSession sharedSession] dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
            NSLog(@"队列组网络请求1：一个耗时操作已完成！");
            dispatch_group_leave(group);
        }];
        [task resume];
    });
    dispatch_group_async(group, queue, ^{
        dispatch_group_enter(group);
        NSURLSessionDataTask *task=[[NSURLSession sharedSession] dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
            NSLog(@"队列组网络请求2：一个耗时操作已完成！");
            dispatch_group_leave(group);
        }];
        [task resume];
    });
    dispatch_group_async(group, queue, ^{
        dispatch_group_enter(group);
        NSURLSessionDataTask *task=[[NSURLSession sharedSession] dataTaskWithRequest:request completionHandler:^(NSData * _Nullable data, NSURLResponse * _Nullable response, NSError * _Nullable error) {
            NSLog(@"队列组网络请求3：一个耗时操作已完成！");
            dispatch_group_leave(group);
        }];
        [task resume];
    });
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"队列组：前面的耗时操作都完成了，回到主线程");
    });

定时器

    __block NSInteger timeOut = 10;
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
    dispatch_source_set_timer(timer,
                              dispatch_time(DISPATCH_TIME_NOW, 0 * NSEC_PER_SEC),
                              1 * NSEC_PER_SEC, 0);
    dispatch_source_set_event_handler(timer, ^{
        
        if (timeOut <= 0) {
            dispatch_source_cancel(timer);
            NSLog(@"定时器停止");
        } else {
            NSLog(@"执行任务");
            timeOut--;
        }
    });
    dispatch_resume(timer);

信号量

- (void)main{
    self.semaphore = dispatch_semaphore_create(0);
    [self semaphorePlus];
    [self semaphoreWait];
}
- (void)semaphoreWait{
    // 如果信号量的值 > 0，就让信号量的值减1，然后继续往下执行代码
    // 如果信号量的值 <= 0，就会休眠等待，直到信号量的值变成>0，就让信号量的值减1，然后继续往下执行代码
    NSLog(@"开始等待");
    dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"等待结束");
    
}
- (void)semaphorePlus{
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 5.0 * NSEC_PER_SEC), dispatch_get_global_queue(0, 0), ^{
        NSLog(@"延迟5秒执行");
        NSLog(@"信号量加1");
        dispatch_semaphore_signal(self.semaphore);
    });
}

设置优先级

dispatch_queue_t myQueue = dispatch_queue_create("com.sf.test"， NULL); 
dispatch_queue_t globalHightQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH， 0);
//第一个参数为要设置优先级的queue，第二个参数是参照物，既将第一个queue的优先级和第二个queue的优先级设置一样。
dispatch_set_target_queue(myQueue， globalHighQueue);

GCD相关函数说明

1. `Dispatch Queue`：

//各种队列的获取方法
-(void)getQueue{

    //主队列的获取方法:主队列是串行队列，主队列中的任务都将在主线程中执行
    dispatch_queue_t mainqueue = dispatch_get_main_queue();

    //串行队列的创建方法:第一个参数表示队列的唯一标识,第二个参数用来识别是串行队列还是并发队列（若为NULL时，默认是DISPATCH_QUEUE_SERIAL）
    dispatch_queue_t seriaQueue = dispatch_queue_create("com.test.testQueue", DISPATCH_QUEUE_SERIAL);

    //并发队列的创建方法:第一个参数表示队列的唯一标识,第二个参数用来识别是串行队列还是并发队列（若为NULL时，默认是DISPATCH_QUEUE_SERIAL）
    dispatch_queue_t concurrentQueue = dispatch_queue_create("com.test.testQueue", DISPATCH_QUEUE_CONCURRENT);

    //全局并发队列的获取方法:第一个参数表示队列优先级,我们选择默认的好了,第二个参数flags作为保留字段备用,一般都直接填0
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
}

2. `dispatch_queue_creat`：

//自定义队列的创建方法
-(void)queue_create{
    //串行队列的创建方法:第一个参数表示队列的唯一标识,第二个参数用来识别是串行队列还是并发队列（若为NULL时，默认是DISPATCH_QUEUE_SERIAL）
    dispatch_queue_t seriaQueue = dispatch_queue_create("com.test.testQueue", DISPATCH_QUEUE_SERIAL);

    //并发队列的创建方法:第一个参数表示队列的唯一标识,第二个参数用来识别是串行队列还是并发队列（若为NULL时，默认是DISPATCH_QUEUE_SERIAL）
    dispatch_queue_t concurrentQueue = dispatch_queue_create("com.test.testQueue", DISPATCH_QUEUE_CONCURRENT);
}

3. `dispatch_set_target_queue`：

dispatch_set_target_queue可以更改Dispatch Queue的执行优先级 dispatch_queue_create函数生成的DisPatch Queue不管是Serial DisPatch Queue还是Concurrent Dispatch Queue,执行的优先级都与默认优先级的Global Dispatch queue相同,如果需要变更生成的Dispatch Queue的执行优先级则需要使用dispatch_set_target_queue函数。

//使用dispatch_set_target_queue更改Dispatch Queue的执行优先级
-(void)testTargetQueue1{

    NSLog(@"----start-----当前线程---%@",[NSThread currentThread]);

    //串行队列的创建方法:第一个参数表示队列的唯一标识,第二个参数用来识别是串行队列还是并发队列（若为NULL时，默认是DISPATCH_QUEUE_SERIAL）
    dispatch_queue_t seriaQueue = dispatch_queue_create("com.test.testQueue", NULL);

    //指定一个任务
    dispatch_async(seriaQueue, ^{

        //这里线程暂停2秒,模拟一般的任务的耗时操作
        [NSThread sleepForTimeInterval:2];

        NSLog(@"----执行第一个任务---当前线程%@",[NSThread currentThread]);
    });

    //全局并发队列的获取方法:第一个参数表示队列优先级,我们选择默认的好了,第二个参数flags作为保留字段备用,一般都直接填0
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    //指定一个任务
    dispatch_async(globalQueue, ^{

        //这里线程暂停2秒,模拟一般的任务的耗时操作
        [NSThread sleepForTimeInterval:2];

        NSLog(@"----执行第二个任务---当前线程%@",[NSThread currentThread]);
    });

    //第一个参数为要设置优先级的queue,第二个参数是参照物，即将第一个queue的优先级和第二个queue的优先级设置一样。
    //第一个参数如果是系统提供的【主队列】或【全局队列】,则不知道会出现什么情况，因此最好不要设置第一参数为系统提供的队列
    dispatch_set_target_queue(seriaQueue,globalQueue);

    NSLog(@"----end-----当前线程---%@",[NSThread currentThread]);

}

dispatch_set_target_queue除了能用来设置队列的优先级之外，还能够创建队列的层次体系，当我们想让不同队列中的任务同步的执行时，我们可以创建一个串行队列，然后将这些队列的target指向新创建的队列即可。

- (void)testTargetQueue2 {

    NSLog(@"----start-----当前线程---%@",[NSThread currentThread]);

    dispatch_queue_t targetQueue = dispatch_queue_create("com.test.target_queue", DISPATCH_QUEUE_SERIAL);

    dispatch_queue_t queue1 = dispatch_queue_create("com.test.queue1", DISPATCH_QUEUE_SERIAL);

    dispatch_queue_t queue2 = dispatch_queue_create("com.test.queue2", DISPATCH_QUEUE_CONCURRENT);

    dispatch_set_target_queue(queue1, targetQueue);

    dispatch_set_target_queue(queue2, targetQueue);

    //指定一个异步任务
    dispatch_async(queue1, ^{
        NSLog(@"----执行第一个任务---当前线程%@",[NSThread currentThread]);
        [NSThread sleepForTimeInterval:2];
    });

    //指定一个异步任务
    dispatch_async(queue2, ^{
        NSLog(@"----执行第二个任务---当前线程%@",[NSThread currentThread]);
        [NSThread sleepForTimeInterval:2];
    });

    //指定一个异步任务
    dispatch_async(queue2, ^{
        NSLog(@"----执行第三个任务---当前线程%@",[NSThread currentThread]);
        [NSThread sleepForTimeInterval:2];
    });

    NSLog(@"----end-----当前线程---%@",[NSThread currentThread]);

}

4. `dispatch_after`：

//延时执行,需要注意的是：dispatch_after函数并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到主队列中。严格来说，这个时间并不是绝对准确的，但想要大致延迟执行任务，dispatch_after函数是很有效的。
-(void)dispatch_after{
    NSLog(@"----start-----当前线程---%@",[NSThread currentThread]);

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 2秒后异步追加任务代码到主队列等待执行
        NSLog(@"----执行第一个任务---当前线程%@",[NSThread currentThread]);
    });

    NSLog(@"----end-----当前线程---%@",[NSThread currentThread]);

}

5. `dispatch_once`：

//只执行一次,通常在创建单例时使用，多线程环境下也能保证线程安全
-(void)dispatch_once_1{

    NSLog(@"----start-----当前线程---%@",[NSThread currentThread]);

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"----只执行一次的任务---当前线程%@",[NSThread currentThread]);
    });

    NSLog(@"----end-----当前线程---%@",[NSThread currentThread]);

}

6. `dispatch_apply`：

//快速遍历方法，可以替代for循环的函数。dispatch_apply按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。
//会创建新的线程，并发执行
-(void)dispatch_apply{

    NSLog(@"----start-----当前线程---%@",[NSThread currentThread]);

    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_apply(100, globalQueue, ^(size_t index) {
        NSLog(@"执行第%zd次的任务---%@",index, [NSThread currentThread]);
    });

    NSLog(@"----end-----当前线程---%@",[NSThread currentThread]);

}

7. `dispatch_group`：

//队列组:当我们遇到需要异步下载3张图片，都下载完之后再拼接成一个整图的时候，就需要用到gcd队列组。
-(void)dispatch_group{

    NSLog(@"----start-----当前线程---%@",[NSThread currentThread]);

    dispatch_group_t group =  dispatch_group_create();

    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 第一个任务
        [NSThread sleepForTimeInterval:2];

        NSLog(@"----执行第一个任务---当前线程%@",[NSThread currentThread]);

    });

    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 第二个任务
        [NSThread sleepForTimeInterval:2];

        NSLog(@"----执行第二个任务---当前线程%@",[NSThread currentThread]);
    });

    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        // 第三个任务
        [NSThread sleepForTimeInterval:2];

        NSLog(@"----执行第三个任务---当前线程%@",[NSThread currentThread]);
    });

    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        [NSThread sleepForTimeInterval:2];

        NSLog(@"----执行最后的汇总任务---当前线程%@",[NSThread currentThread]);
    });

    //若想执行完上面的任务再走下面这行代码可以加上下面这句代码

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

    NSLog(@"----end-----当前线程---%@",[NSThread currentThread]);
}

dispatch_group_enter 标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数+1
dispatch_group_leave 标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数-1。
当 group 中未执行完毕任务数为0的时候，才会使dispatch_group_wait解除阻塞，以及执行追加到dispatch_group_notify中的任务。

-(void)dispatch_group_1{

    NSLog(@"----start-----当前线程---%@",[NSThread currentThread]);

    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, ^{
        // 第一个任务
        [NSThread sleepForTimeInterval:2];

        NSLog(@"----执行第一个任务---当前线程%@",[NSThread currentThread]);

        dispatch_group_leave(group);
    });

    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        // 第二个任务
        [NSThread sleepForTimeInterval:2];

        NSLog(@"----执行第二个任务---当前线程%@",[NSThread currentThread]);

        dispatch_group_leave(group);
    });

    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        // 第三个任务
        [NSThread sleepForTimeInterval:2];

        NSLog(@"----执行第三个任务---当前线程%@",[NSThread currentThread]);

        dispatch_group_leave(group);
    });

    dispatch_group_notify(group, dispatch_get_main_queue(), ^{

        [NSThread sleepForTimeInterval:2];
        NSLog(@"----执行最后的汇总任务---当前线程%@",[NSThread currentThread]);
    });

    NSLog(@"----end-----当前线程---%@",[NSThread currentThread]);

}

8. `dispatch_semaphore`：

//信号量
//总结:信号量设置的是2，在当前场景下，同一时间内执行的线程就不会超过2，先执行2个线程，等执行完一个，下一个会开始执行。
-(void)dispatch_semaphore{

    NSLog(@"----start-----当前线程---%@",[NSThread currentThread]);

    dispatch_semaphore_t semaphore = dispatch_semaphore_create(2);

    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    //任务1
    dispatch_async(queue, ^{

        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

        NSLog(@"----开始执行第一个任务---当前线程%@",[NSThread currentThread]);

        [NSThread sleepForTimeInterval:2];

        NSLog(@"----结束执行第一个任务---当前线程%@",[NSThread currentThread]);

        dispatch_semaphore_signal(semaphore);
    });

    //任务2
    dispatch_async(queue, ^{

        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

        NSLog(@"----开始执行第二个任务---当前线程%@",[NSThread currentThread]);

        [NSThread sleepForTimeInterval:1];

        NSLog(@"----结束执行第二个任务---当前线程%@",[NSThread currentThread]);

        dispatch_semaphore_signal(semaphore);
    });

    //任务3
    dispatch_async(queue, ^{

        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

        NSLog(@"----开始执行第三个任务---当前线程%@",[NSThread currentThread]);

        [NSThread sleepForTimeInterval:2];

        NSLog(@"----结束执行第三个任务---当前线程%@",[NSThread currentThread]);

        dispatch_semaphore_signal(semaphore);
    });

    NSLog(@"----end-----当前线程---%@",[NSThread currentThread]);

}

9. `Dispatch I/O`：

//以下为苹果中使用Dispatch I/O和Dispatch Data的例子
pipe_q = dispatch_queue_create("PipeQ",NULL);
pipe_channel = dispatch_io_create(DISPATCH_IO_STREAM,fd,pipe_q,^(int err){
   close(fd);
});

*out_fd = fdpair[I];

dispatch_io_set_low_water(pipe_channel,SIZE_MAX);

dispatch_io_read(pipe_channel,0,SIZE_MAX,pipe_q, ^(bool done,dispatch_data_t pipe data,int err){
   if(err == 0)
     {
       size_t len = dispatch_data_get_size(pipe data);
       if(len > 0)
       {
          const char *bytes = NULL;
          char *encoded;

          dispatch_data_t md = dispatch_data_create_map(pipe data,(const void **)&bytes,&len);
          asl_set((aslmsg)merged_msg,ASL_KEY_AUX_DATA,encoded);
          free(encoded);
          _asl_send_message(NULL,merged_msg,-1,NULL);
          asl_msg_release(merged_msg);
          dispatch_release(md);
       }
      }

      if(done)
      {
         dispatch_semaphore_signal(sem);
         dispatch_release(pipe_channel);
         dispatch_release(pipe_q);
      }
});

10. `dispatch_barrier_async`：

//隔断方法：当前面的写入操作全部完成之后，再执行后面的读取任务。当然也可以用Dispatch Group和dispatch_set_target_queue,只是比较而言，dispatch_barrier_async会更加顺滑
-(void)dispatch_barrier_async{

    NSLog(@"----start-----当前线程---%@",[NSThread currentThread]);

    dispatch_queue_t queue = dispatch_queue_create("com.test.testQueue", DISPATCH_QUEUE_CONCURRENT);

    dispatch_async(queue, ^{
        // 第一个写入任务
        [NSThread sleepForTimeInterval:3];

        NSLog(@"----执行第一个写入任务---当前线程%@",[NSThread currentThread]);

    });
    dispatch_async(queue, ^{
        // 第二个写入任务
        [NSThread sleepForTimeInterval:1];

        NSLog(@"----执行第二个任务---当前线程%@",[NSThread currentThread]);

    });

    dispatch_barrier_async(queue, ^{
        // 等待处理
        [NSThread sleepForTimeInterval:2];

        NSLog(@"----等待前面的任务完成---当前线程%@",[NSThread currentThread]);

    });

    dispatch_async(queue, ^{
        // 第一个读取任务
        [NSThread sleepForTimeInterval:2];

        NSLog(@"----执行第一个读取任务---当前线程%@",[NSThread currentThread]);

    });
    dispatch_async(queue, ^{
        // 第二个读取任务
        [NSThread sleepForTimeInterval:2];

        NSLog(@"----执行第二个读取任务---当前线程%@",[NSThread currentThread]);

    });

    NSLog(@"----end-----当前线程---%@",[NSThread currentThread]);

}

11. `dispatch_suspend` & `dispatchp_resume`：

//场景：当追加大量处理到Dispatch Queue时，在追加处理的过程中，有时希望不执行已追加的处理。例如演算结果被Block截获时，一些处理会对这个演算结果造成影响。在这种情况下，只要挂起Dispatch Queue即可。当可以执行时再恢复。
//总结:dispatch_suspend，dispatch_resume提供了“挂起、恢复”队列的功能，简单来说，就是可以暂停、恢复队列上的任务。但是这里的“挂起”，并不能保证可以立即停止队列上正在运行的任务，也就是如果挂起之前已经有队列中的任务在进行中，那么该任务依然会被执行完毕
-(void)dispatch_suspend{

    NSLog(@"----start-----当前线程---%@",[NSThread currentThread]);

    dispatch_queue_t queue = dispatch_queue_create("com.test.testQueue", DISPATCH_QUEUE_SERIAL);

    dispatch_async(queue, ^{
        // 执行第一个任务
        [NSThread sleepForTimeInterval:5];

        NSLog(@"----执行第一个任务---当前线程%@",[NSThread currentThread]);

    });

    dispatch_async(queue, ^{
        // 执行第二个任务
        [NSThread sleepForTimeInterval:5];

        NSLog(@"----执行第二个任务---当前线程%@",[NSThread currentThread]);

    });

    dispatch_async(queue, ^{
        // 执行第三个任务
        [NSThread sleepForTimeInterval:5];

        NSLog(@"----执行第三个任务---当前线程%@",[NSThread currentThread]);
    });

    //此时发现意外情况，挂起队列
    NSLog(@"suspend");
    dispatch_suspend(queue);

    //挂起10秒之后，恢复正常
    [NSThread sleepForTimeInterval:10];

    //恢复队列
    NSLog(@"resume");
    dispatch_resume(queue);

    NSLog(@"----end-----当前线程---%@",[NSThread currentThread]);

}

GCD 相关函数
串行同步串行异步并行同步并行异步主队列同步会死锁主队列异步异步处理耗时，回主线程刷新UI 栅栏函数 ...
OC多线程学习（二） - GCD
本文内容： GCD相关概念有关GCD的几道面试题源码分析：队列和异步函数 GCD概念 GCD是Grand Ce...
ios多线程操作— GCD延迟操作和相关使用方法
ios多线程操作— GCD延迟操作和相关使用方法 0x01.iOS版本使用GCD函数可以进行延时操作，该函数为 ...
iOS-GCD常用函数和栅栏函数
GCD常用函数 GCD栅栏函数
iOS底层探索之多线程(四)—GCD的队列
回顾在上篇博客已经介绍了GCD的队列和函数，我们对 GCD有了一个初步的认识，那么本篇博客将继续介绍GCD的相关...
扩展GCD(求逆元,解同余方程等等)
首先要知道gcd函数的基本性质:gcd(a,b)=gcd(b,a)=gcd(|a|,|b|)=gcd(b,a%b)...
iOS开发之多线程笔记(四)之GCD
Grand Central Dispatch 纯C语言，提供了非常多强大的函数线程相关知识以及GCD概念介绍不是...
GCD栅栏函数, 快速迭代和调度组的使用
今天介绍几个比较重要的GCD函数: GCD栅栏函数: 同步栅栏函数: 会发生阻塞异步栅栏函数: 不会发生阻塞栅...
GCD栅栏
GCD栅栏 //GCD是基于C的,所有barrier是函数//GCD中的barrier函数有两种形式 //第一种 ...
iOS Objective-C GCD之函数篇
iOS Objective-C GCD之函数篇 1. GCD 中函数简介在上一篇队列篇中我们简要的介绍了GCD中...

GCD 相关函数

GCD相关函数说明

1. `Dispatch Queue`：

2. `dispatch_queue_creat`：

3. `dispatch_set_target_queue`：

4. `dispatch_after`：

5. `dispatch_once`：

6. `dispatch_apply`：

7. `dispatch_group`：

8. `dispatch_semaphore`：

9. `Dispatch I/O`：

10. `dispatch_barrier_async`：

11. `dispatch_suspend` & `dispatchp_resume`：

相关文章

GCD 相关函数

OC多线程学习（二） - GCD

ios多线程操作— GCD延迟操作和相关使用方法

iOS-GCD常用函数和栅栏函数

iOS底层探索之多线程(四)—GCD的队列

扩展GCD(求逆元,解同余方程等等)

iOS开发之多线程笔记(四)之GCD

GCD栅栏函数, 快速迭代和调度组的使用

GCD栅栏

iOS Objective-C GCD之函数篇

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

GCD 相关函数

GCD相关函数说明

1. Dispatch Queue：

2. dispatch_queue_creat：

3. dispatch_set_target_queue：

4. dispatch_after：

5. dispatch_once：

6. dispatch_apply：

7. dispatch_group：

8. dispatch_semaphore：

9. Dispatch I/O：

10. dispatch_barrier_async：

11. dispatch_suspend & dispatchp_resume：

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

1. `Dispatch Queue`：

2. `dispatch_queue_creat`：

3. `dispatch_set_target_queue`：

4. `dispatch_after`：

5. `dispatch_once`：

6. `dispatch_apply`：

7. `dispatch_group`：

8. `dispatch_semaphore`：

9. `Dispatch I/O`：

10. `dispatch_barrier_async`：

11. `dispatch_suspend` & `dispatchp_resume`：