GCD 与线程的关系及常用操作

dispatch queue

  • 串行队列(DISPATCH_QUEUE_CONCURRENT)

    • serial dispatch queue中的block按照先进先出(FIFO)的顺序去执行,
    • 用户可以根据需要创建任意多的serial dispatch queue
    • serial dispatch queue彼此之间是并发的
  • 并行队列(DISPATCH_QUEUE_SERIAL)

    • 一次性并发执行一个或者多个task
    • 系统提供了四个global concurrent queue,使用dispatch_get_global_queue函数就可以获取
  • Main Dispatch Queue

    • 绑定在主线程
    • FIFO
    • 全局的
  • 全局队列

    • main queue
    • 四个global concurrent queue
  • 用户创建

    • 串行
    • 并行

全局队列

main queue 的所有的操作都在主线程中进行,注意 main queue 是一个串行队列

dispatch_queue_t dispatch_get_main_queue(void)

返回全局共有的 并行队列, 主要有四个优先级

  • DISPATCH_QUEUE_PRIORITY_HIGH: QOS_CLASS_USER_INITIATED
  • DISPATCH_QUEUE_PRIORITY_DEFAULT: QOS_CLASS_DEFAULT
  • DISPATCH_QUEUE_PRIORITY_LOW: QOS_CLASS_UTILITY
  • DISPATCH_QUEUE_PRIORITY_BACKGROUND: QOS_CLASS_BACKGROUND
dispatch_queue_t dispatch_get_global_queue(long identifier, unsigned long flags);

用户自己创建

用户可以通过设置 attr 参数,创建出 串行 或 并行的队列

dispatch_queue_t dispatch_queue_create(const char *_Nullable label,
        dispatch_queue_attr_t _Nullable attr);

dispatch_get_current_queue

不要用!

dispatch queue 和 线程的关系

除了 main queue 在主线程,其他没啥关系~

- (void)mainQueueAndThread
{
    NSLog(@"thread out queue: %@", [NSThread currentThread]);

    dispatch_queue_t main_queue = dispatch_get_main_queue();

    for (NSInteger i = 0; i< 100; i++) {

//        /**
//         *  !!!特别注意,这里会形成死锁
//         */
//        dispatch_sync(main_queue, ^{
//            NSLog(@"thread in main queue ,i:%@, thread:%@", @(i), [NSThread currentThread]);
//        });

        /**
         *  通过 Log 发现,所有的任务都执行在主线程上
         */
        dispatch_async(main_queue, ^{
            NSLog(@"dispatch_async in main queue ,i:%@, thread:%@", @(i), [NSThread currentThread]);
        });
    }
}

- (void)serialQueueAndThread
{
    NSLog(@"thread out queue: %@", [NSThread currentThread]);

    dispatch_queue_t serial_queue = dispatch_queue_create("me.terry.MySerialQueue", DISPATCH_QUEUE_SERIAL);

    for (NSInteger i = 0; i< 100; i++) {
        dispatch_sync(serial_queue, ^{
            NSLog(@"dispatch_sync in serial queue ,i:%@, thread:%@", @(i), [NSThread currentThread]);
        });

        /**
         *  通过 Log 发现:
         *  1. 虽然是串行队列, 但是没有对应的串行线程,任务执行在不同的线程上
         *  2. 虽然使用异步派发,但是仍然遵循 FIFO
         *  3. 虽然指定了队列,但是执行同步操作的时候,仍然执行在主线程上
         */
        dispatch_async(serial_queue, ^{
            NSLog(@"dispatch_async in serial queue ,i:%@, thread:%@", @(i), [NSThread currentThread]);
        });
    }
}

- (void)concurrentQueueAndThread
{
    NSLog(@"thread out queue: %@", [NSThread currentThread]);

    dispatch_queue_t concurrent_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);

    for (NSInteger i = 0; i< 100; i++) {
        /**
         *  通过的 Log 发现:
         *  1. 虽然指定了并行队列,但是执行同步操作的时候,仍然执行在主线程上
         *  2. 并行队列 和 上述的 serial_queue 有一些线程是相同的,所以队列和线程是没有对应关系的
         *  3. 异步派发,并发执行task,不遵循 FIFO了
         */
        dispatch_sync(concurrent_queue, ^{
            NSLog(@"dispatch_sync in concurrent queue ,i:%@, thread:%@", @(i), [NSThread currentThread]);
        });
        dispatch_async(concurrent_queue, ^{
            NSLog(@"dispatch_async in concurrent queue ,i:%@, thread:%@", @(i), [NSThread currentThread]);
        });
    }
}

- (void)dispatchSyncAndThread
{
    NSLog(@"main thread: %@", [NSThread mainThread]);

    NSThread *testThread = [[NSThread alloc] initWithBlock:^{
        NSLog(@"thread out queue: %@", [NSThread currentThread]);

        dispatch_queue_t main_queue = dispatch_get_main_queue();
        dispatch_queue_t serial_queue = dispatch_queue_create("me.terry.MySerialQueue", DISPATCH_QUEUE_SERIAL);
        dispatch_queue_t concurrent_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);

        for (NSInteger i = 0; i< 100; i++) {
            /**
             *  执行在主线程
             */
            dispatch_sync(main_queue, ^{
                NSLog(@"dispatch_sync in main queue ,i:%@, thread:%@", @(i), [NSThread currentThread]);
            });
        }
        for (NSInteger i = 0; i< 100; i++) {
            /**
             *  执行在上下文线程
             */
            dispatch_sync(serial_queue, ^{
                NSLog(@"dispatch_sync in serial queue ,i:%@, thread:%@", @(i), [NSThread currentThread]);
            });
        }
        for (NSInteger i = 0; i< 100; i++) {
            /**
             *  执行在上下文线程
             */
            dispatch_sync(concurrent_queue, ^{
                NSLog(@"dispatch_sync in concurrent queue ,i:%@, thread:%@", @(i), [NSThread currentThread]);
            });
        }

    }];
    [testThread start];
}

队列的操作

同步操作

void dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

dispatch_sync 会阻塞线程,不论指定同步队列还是异步队列,都会等待1执行完,才会执行2

dispatch_sync(queue, ^{
    sleep(3);
    // do something 1
});

// do something 2

异步操作

void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

- (void)dispatchAsyncDemo
{
    dispatch_queue_t serial_queue = dispatch_queue_create("me.terry.MySerialQueue", DISPATCH_QUEUE_SERIAL);

    /**
     *  不论指定是串行队列还是并行队列,不会 block , 顺序 3 1 2
     */
    dispatch_async(serial_queue, ^{
        NSLog(@"%@",@"in async block 111");
        sleep(3);
        NSLog(@"%@",@"in async block 222");
    });
    NSLog(@"%@",@"in sync block 333");
}

dispatch_once

- (void)dispatchOnceDemo
{
    NSLog(@"这个 Log 每次都会出现");
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"这个 Log 只会出一次");
    });
}

dispatch_group

- (void)dispatchGroupDemo
{
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_t dispatchGroup = dispatch_group_create();
    for (NSInteger i = 0; i < 10000; i++) {
        dispatch_group_async(dispatchGroup, queue, ^{
            NSLog(@"dispatch Group Async Demo index:%@",@(i));
        });
    }

    // 非阻塞
    dispatch_queue_t notifyQueue = dispatch_get_main_queue();
    dispatch_group_notify(dispatchGroup, notifyQueue, ^{
        // Continue processing after completing tasks
        NSLog(@"Dispatch Group Done with notification");
    });
    NSLog(@"dispatch_group_notify will not block the thread");

    // 阻塞当前线程
    dispatch_group_wait(dispatchGroup, DISPATCH_TIME_FOREVER);
    // Continue processing after completing tasks
    NSLog(@"Dispatch Group Done after blocking thread");
}

dispatch_apply

- (void)dispatchApplyDemo
{
    /**
     *  dispatch apply 可以实现类似 dispatch group 的功能, 注意防止同步造成的死锁问题
     */
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_apply(1000, queue, ^(size_t i) {
        NSLog(@"dispatch Apply Demo index:%@",@(i));
    });
    NSLog(@"Dispatch Apply Demo Done after blocking thread");
}

dispatch_barrier

- (void)dispatchBarrierDemo
{
    __block NSInteger someValue = 0;

    someValue = 0;

    void(^readValueBlock)(void) = ^() {
        NSLog(@"some value:%@", @(someValue));
    };

    void(^writeValueBlock)(void) = ^() {
        someValue ++;
    };

    /**
     *  这里注意 dispatch_barrier_async 只能在 使用 dispatch_queue_create 创建的 队列中使用
     *  如果在 globe queue 中使用,与 dispatch_async 没有区别
     *  https://stackoverflow.com/questions/10808476/how-should-i-use-gcd-dispatch-barrier-async-in-ios-seems-to-execute-before-and
     */
    dispatch_queue_t queue = dispatch_queue_create("12312312", DISPATCH_QUEUE_CONCURRENT);

    /**
     *  串行队列可以很好的防止数据竞争的问题, 但是并发队列有可能会有更好的性能
     *  但是由于并发队列任务的执行顺序不能确定,可能发生数据竞争,导致最终结果不正确
     */
    for (NSInteger i = 0; i < 1000; i++) {
        dispatch_async(queue, readValueBlock);
    }
    for (NSInteger i = 0; i < 1000; i++) {
        dispatch_async(queue, writeValueBlock);
    }
    for (NSInteger i = 0; i < 1000; i++) {
        dispatch_async(queue, readValueBlock);
    }

    dispatch_barrier_sync(queue, ^{
        someValue = 0;
        NSLog(@"----------------------");
    });

    /**
     *  使用dispatch_barrier_async 可以保证写操作执行时,不会发生数据竞争,保证最终结果正确
     *  但是好像没有啥效果
     */
    for (NSInteger i = 0; i < 1000; i++) {
        dispatch_async(queue, readValueBlock);
    }
    for (NSInteger i = 0; i < 1000; i++) {
        /**
         *  dispatch_barrier_async 中文叫栅栏函数,它等待所有位于barrier函数之前的操作执行完毕后执行,并且在barrier函数执行之后,barrier函数之后的操作才会得到执行
         */
        dispatch_barrier_async(queue, writeValueBlock);
    }
    for (NSInteger i = 0; i < 1000; i++) {
        dispatch_async(queue, readValueBlock);
    }
}

dadas

- (void)dispatchSuspendAndResumeDemo
{
    void(^taskBlock)(void) = ^() {
        NSLog(@"task start");
        sleep(2);
        NSLog(@"task stop");
    };

    dispatch_queue_t queue = dispatch_queue_create("12312312", DISPATCH_QUEUE_SERIAL);

    for (NSInteger i = 0; i < 10; i++) {
        dispatch_async(queue, taskBlock);
    }

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        /**
         *  挂起的队列,已经执行的任务仍然会继续执行,但是队列中其他没有执行的任务不会执行
         */
        dispatch_suspend(queue);
        NSLog(@"dispatch_suspend");
    });

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        /**
         *  队列恢复以后,其他的任务继续执行
         */
        dispatch_resume(queue);
        NSLog(@"dispatch_resume");
    });
}

dispatch_semephore

- (void)dispatchSemaphoreDemo
{
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    // 不考虑顺序,向NSMutableArray 添加元素
    /*
    NSMutableArray *array = [NSMutableArray array];
    for (NSInteger i = 0; i < 10000; i++) {
        dispatch_async(queue, ^{
            [array addObject:@(i)]; // 异常结束
        });
    }
     */

    /**
     *  生成信号量,
     *  初始值为1 -》可访问 NSMutableArray 类对象的线程同时 只有 1 个
     */
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
    NSMutableArray *array = [NSMutableArray array];

    for (NSInteger i = 0; i < 10000; i++) {
        dispatch_async(queue, ^{
            /**
             *  计数器为 0 的时候等待,直到大于等于 1
             */
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            /**
             *  执行到此时,计数器减 1
             *  由于只有1, 所以此时 计数器为0,其他线程不会通过,保证只有一个线程
             */
            [array addObject:@(i)];
            /**
             *  计数器+1,
             *  注意:如果系统销毁时,semaphore的技术比初始值小,会认为处于 in use 的状态,会 crash
             */
            dispatch_semaphore_signal(semaphore);
        });
    }
}

最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

推荐阅读更多精彩内容

  • GCD (Grand Central Dispatch) :iOS4 开始引入,使用更加方便,程序员只需要将任务添...
    池鹏程阅读 1,366评论 0 2
  • 本篇博客共分以下几个模块来介绍GCD的相关内容: 多线程相关概念 多线程编程技术的优缺点比较? GCD中的三种队列...
    有梦想的老伯伯阅读 1,031评论 0 4
  • 多线程是程序开发中非常基础的一个概念,大家在开发过程中应该或多或少用过相关的东西。同时这恰恰又是一个比较棘手的概念...
    小笨狼阅读 7,027评论 12 70
  • 基于自 raywenderlich.com 在2015年的两篇文章 Grand Central Dispatch ...
    seedante阅读 1,401评论 0 7
  • 一、前言 本篇博文介绍的是iOS中常用的几个多线程技术: NSThread GCD NSOperation 由于a...
    和珏猫阅读 588评论 0 1