美文网首页iOSiOS深入理解iOS精华
iOS多线程GCD简介(二)

iOS多线程GCD简介(二)

作者: JamesYu | 来源:发表于2015-01-03 16:41 被阅读3581次

    在上一篇中,我们主要讲了Dispatch Queue相关的内容。这篇主要讲一下一些和实际相关的使用实例,Dispatch Groups和Dispatch Semaphore。

    dispatch_after

    在我们开发过程中经常会用到在多少秒后执行某个方法,通常我们会用这个- (void)performSelector:(SEL)aSelector withObject:(id)anArgument afterDelay:(NSTimeInterval)delay函数。不过现在我们可以使用一个新的方法。

    dispatch_time_t delayTime = dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC);
        dispatch_after(delayTime, dispatch_get_main_queue(), ^{
            //do your task
        });
    

    这样我们就定义了一个延迟2秒后执行的任务。不过在这里有一点需要说明的是,无论你用的是- (void)performSelector:(SEL)aSelector withObject:(id)anArgument afterDelay:(NSTimeInterval)delay还是dispatch_after这个方法。并不是说在你指定的延迟后立即运行,这些方法都是基于单线程的,它只是将你延迟的操作加入到队列里面去。由于队列里面都是FIFO,所以必须在你这个任务之前的操作完成后才会执行你的方法。这个延迟只是大概的延迟。如果你在主线程里面调用这个方法,如果你主线程现在正在处理一个非常耗时的任务,那么你这个延迟可能就会偏差很大。这个时候你可以再开个线程,在里面执行你的延迟操作。

    //放到全局默认的线程里面,这样就不必等待当前调用线程执行完后再执行你的方法
    dispatch_time_t delayTime = dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC);
        dispatch_after(delayTime, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            //do your task
        });
    

    dispatch_once

    这个想必大家都非常的熟悉,这个在单例初始化的时候是苹果官方推荐的方法。这个函数可以保证在应用程序中只执行指定的任务一次。即使在多线程的环境下执行,也可以保证百分之百的安全。

        static id instance;
        static dispatch_once_t predicate;
    
        dispatch_once(&predicate, ^{
            //your init
        });
    
        return instance;
    }
    

    这里面的predicate必须是全局或者静态对象。在多线程下同时访问时,这个方法将被线程同步等待,直到指定的block执行完成。

    dispatch_apply

    这个方法是执行循环次数固定的迭代,如果在并发的queue里面可以提高性能。比如一个固定次数的for循环

    for (int i = 0; i < 1000; i ++) {
            NSLog(@"---%d---", i);
        }
    

    如果只是在一个线程里面或者在一个串行的队列中是一样的,一个个执行。
    现在我们用dispatch_apply来写这个循环:

    dispatch_apply([array count], defaultQueue, ^(size_t i) {
            NSLog(@"----%@---", array[i]);
        });
        NSLog(@"end");
    

    这个方法执行后,它将像这个并发队列中不断的提交执行的block。这个i是从0开始的,最后一个是[array count] - 1

    使用这个方法有几个注意点:

    1. 这个方法调用的时候会阻塞当前的线程,也就是上面的循环全部执行完毕后,才会输出end
    2. 在你使用这个任务进行操作的时候,你应该确保你要执行的各个任务是独立的,而且执行顺序也是无关紧要的。
    3. 在你使用这个方法的时候,你还是要权衡下整体的性能的,如果你执行的任务时间比线程切换的时间还短。那就得不偿失了。

    dispatch_group

    在实际开发中,我们可能需要在一组操作全部完成后,才做其他操作。比如上传一组图片,或者下载多个文件。希望在全部完成时给用户一个提示。如果这些操作在串行化的队列中执行的话,那么你可以很明确的知道,当最后一个任务执行完成后,就全部完成了。这样的操作也并木有发挥多线程的优势。我们可以在并发的队列中进行这些操作,但是这个时候我们就不知道哪个是最后一个完成的了。这个时候我们可以借助dispatch_group:

        dispatch_group_t group = dispatch_group_create();
        dispatch_group_async(group, defaultQueue, ^{
            //task1
            NSLog(@"1");
        });
        dispatch_group_async(group, defaultQueue, ^{
            //task2
            NSLog(@"2");
        });
        dispatch_group_async(group, defaultQueue, ^{
            //task3
            NSLog(@"3");
        });
        dispatch_group_async(group, defaultQueue, ^{
            //task4
            NSLog(@"4");
        });
        dispatch_group_async(group, defaultQueue, ^{
            //task5
            NSLog(@"5");
        });
    
        dispatch_group_notify(group, queue, ^{
            NSLog(@"finish");
        });
    

    我们首先创建一个group然后往里面加入我们要执行的操作,在dispatch_group_notify这个函数里面添加全部完成的操作。上面代码执行的时候,输出的1,2,3,4,5的顺序是不一定的,但是输出的finish一定是在1,2,3,4,5之后。
    对于添加到group的操作还有另外一个方法:

        dispatch_group_enter(group);
        dispatch_group_enter(group);
    
        dispatch_async(defaultQueue, ^{
            NSLog(@"1");
            dispatch_group_leave(group);
        });
    
        dispatch_async(defaultQueue, ^{
            NSLog(@"2");
            dispatch_group_leave(group);
        });
    
        dispatch_group_notify(group, queue, ^{
            NSLog(@"finish");
        });
    

    我们可以用dispatch_group_enter来表示添加任务,dispatch_group_leave来表示有个任务已经完成了。用这个方法一定要注意必须成双成对。

    线程同步

    在多线程中一个比较重要的东西就是线程同步的问题。如果多个线程只是对某个资源只是读的过程,那么就不存在这个问题了。如果某个线程对这个资源需要进行写的操作,那这个时候就会出现数据不一致的问题了。

    使用dispatch_barrier_async

        __block NSString *strTest = @"test";
    
        dispatch_async(defaultQueue, ^{
            if ([strTest isEqualToString:@"test"]) {
                NSLog(@"--%@--1-", strTest);
                [NSThread sleepForTimeInterval:1];
                if ([strTest isEqualToString:@"test"]) {
                    [NSThread sleepForTimeInterval:1];
                    NSLog(@"--%@--2-", strTest);
                } else {
                    NSLog(@"====changed===");
                }
            }
        });
        dispatch_async(defaultQueue, ^{
            NSLog(@"--%@--3-", strTest);
        });
        dispatch_async(defaultQueue, ^{
            strTest = @"modify";
            NSLog(@"--%@--4-", strTest);
        });
    
    

    看看这个模拟的场景,我们让各个线程去访问这个变量,其中有个操作是要修改这个变量。我们把第一个操作先判断有木有改变,然后故意延迟一下,这个时候我们看下输出结果:

    2015-01-03 15:42:21.351 测试[1652:60015] --test--3-
    2015-01-03 15:42:21.351 测试[1652:60013] --modify--4-
    2015-01-03 15:42:21.351 测试[1652:60014] --test--1-
    2015-01-03 15:42:22.355 测试[1652:60014] ====changed===
    

    我们可以看到,再次判断的时候,已经被修改了,如果我们在实际的业务中这样去判断某些关键性的变量,可能就会出现严重的问题。下面看看我们如何使用dispatch_barrier_async来进行同步:

     //并发队列
        dispatch_queue_t concurrentQueue = dispatch_queue_create("com.gcd.concurrentQueue", DISPATCH_QUEUE_CONCURRENT);
    
        __block NSString *strTest = @"test";
    
        dispatch_async(concurrentQueue, ^{
            if ([strTest isEqualToString:@"test"]) {
                NSLog(@"--%@--1-", strTest);
                [NSThread sleepForTimeInterval:1];
                if ([strTest isEqualToString:@"test"]) {
                    [NSThread sleepForTimeInterval:1];
                    NSLog(@"--%@--2-", strTest);
                } else {
                    NSLog(@"====changed===");
                }
            }
        });
        dispatch_async(concurrentQueue, ^{
            NSLog(@"--%@--3-", strTest);
        });
        dispatch_barrier_async(concurrentQueue, ^{
            strTest = @"modify";
            NSLog(@"--%@--4-", strTest);
        });
        dispatch_async(concurrentQueue, ^{
            NSLog(@"--%@--5-", strTest);
        });
    

    现在看下输出结果:

    2015-01-03 16:00:27.552 测试[1786:65947] --test--1-
    2015-01-03 16:00:27.552 测试[1786:65965] --test--3-
    2015-01-03 16:00:29.553 测试[1786:65947] --test--2-
    2015-01-03 16:00:29.553 测试[1786:65947] --modify--4-
    2015-01-03 16:00:29.553 测试[1786:65947] --modify--5-
    

    现在我们可以发现操作4用dispatch_barrier_async加入操作后,前面的操作3之前都操作完成之前这个strTest都没有变。而后面的操作都是改变后的值。这样我们的数据冲突的问题就解决了。
    现在说明下这个函数干的事情,当这个函数加入到队列后,里面block并不是立即执行的,它会先等待之前正在执行的block全部完成后,才执行,并且在它之后加入到队列中的block也在它操作结束后才能恢复之前的并发执行。我们可以把这个函数理解为一条分割线,之前的操作,之后加入的操作。还有一个点要说明的是这个queue必须是用dispatch_queue_create创建出来的才行。

    使用Dispatch Semaphore

    dispatch_semaphore_t 类似信号量,可以用来控制访问某一资源访问数量。
    使用过程:

    1. 先创建一个Dispatch Semaphore对象,用整数值表示资源的可用数量
    2. 在每个任务中,调用dispatch_semaphore_wait来等待
    3. 获得资源就可以进行操作
    4. 操作完后调用dispatch_semaphore_signal来释放资源
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
        __block NSString *strTest = @"test";
    
        dispatch_async(concurrentQueue, ^{
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            if ([strTest isEqualToString:@"test"]) {
                NSLog(@"--%@--1-", strTest);
                [NSThread sleepForTimeInterval:1];
                if ([strTest isEqualToString:@"test"]) {
                    [NSThread sleepForTimeInterval:1];
                    NSLog(@"--%@--2-", strTest);
                } else {
                    NSLog(@"====changed===");
                }
            }
            dispatch_semaphore_signal(semaphore);
        });
        dispatch_async(concurrentQueue, ^{
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            NSLog(@"--%@--3-", strTest);
            dispatch_semaphore_signal(semaphore);
        });
        dispatch_async(concurrentQueue, ^{
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            strTest = @"modify";
            NSLog(@"--%@--4-", strTest);
            dispatch_semaphore_signal(semaphore);
        });
        dispatch_async(concurrentQueue, ^{
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            NSLog(@"--%@--5-", strTest);
            dispatch_semaphore_signal(semaphore);
        });
    

    这样我们一样可以保证,线程的数据安全。

    相关文章

      网友评论

      • Rookie丶:写的非常好啊,大神。膜拜一下。
      • luseike:关于dispatch_barrier_async函数,有一点可能你没说清楚。在该方法执行之前,之后的block是没有添加到队列中去的。dispatch_barrier_async会等待concurrent上的任务全部结束之后,再将指定的任务追加到队列中,然后dispatch_barrier_async函数追加的处理执行完后,concurrent队列开始并行执行
        e4fa7826e618:写的挺好的
        JamesYu:@luseike 嗯,这边是通过控制cpu指令实现的
      • TEASON:这一篇写得太好了, 是原创的吗, 讲的很到位
        TEASON:@JamesYu 我想转发你, 会注明你的出处的
        JamesYu:@TEASON 嗯,

      本文标题:iOS多线程GCD简介(二)

      本文链接:https://www.haomeiwen.com/subject/fpwztttx.html