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);
        });
    }
}

最后编辑于：2017.12.08 16:48:49

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 212,294评论 6赞 493
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 90,493评论 3赞 385
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 157,790评论 0赞 348
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 56,595评论 1赞 284
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 65,718评论 6赞 386
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,906评论 1赞 290
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 39,053评论 3赞 410
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 37,797评论 0赞 268
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 44,250评论 1赞 303
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 36,570评论 2赞 327
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,711评论 1赞 341
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 34,388评论 4赞 332
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 40,018评论 3赞 316
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,796评论 0赞 21
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 32,023评论 1赞 266
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 46,461评论 2赞 360
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 43,595评论 2赞 350