iOS开发中的多线程技术(待续)

GCD：

特点：自动管理线程的生命周期（创建线程、调度任务、销毁线程），使用C语言，自带Block。灵活，方便，功能强大。

  • Queue队列
  • 串行队列 FIFO(First Input First Output) 遵循先入先出原则的队列
    Serial: tasks execute one at a time in FIFO order
dispatch_queue_t queue = dispatch_queue_create("SerialQueue",DISPATCH_QUEUE_SERIAL)
  • 并发队列
    Concurrent: tasks are dequeued in FIFO order, but run concurrently and can finish in any order.
dispatch_queue_t  queue =  dispatch_queue_create ( "ConCurrentQueue" ,  DISPATCH_QUEUE_CONCURRENT );
  • 全局队列 GCD默认提供的全局并发队列，获取
dispatch_queue_t q = dispatch_get_global_queue(long identifier, unsigned long flags)

参数详解：
QOS_CLASS_USER_INTERACTIVE 0x21,              用户交互(希望尽快完成，用户对结果很期望，不要放太耗时操作)
QOS_CLASS_USER_INITIATED 0x19,                用户期望(不要放太耗时操作)     
QOS_CLASS_DEFAULT 0x15,                        默认(不是给程序员使用的，用来重置对列使用的)     
QOS_CLASS_UTILITY 0x11,                        实用工具(耗时操作，可以使用这个选项)    
QOS_CLASS_BACKGROUND 0x09,                     后台   
QOS_CLASS_UNSPECIFIED 0x00,                    未指定

unsigned long flags：苹果官方文档是这样解释的： Flags that are reserved for future use。标记是为了未来使用保留的！所以这个参数应该永远指定为0

  • 主队列 主队列是特殊队列，与主线程一样，程序启动时就存在，所以不需要创建，我们要做的就是直接获取它
dispatch_queue_t queue = dispatch_get_main_queue();

  • 任务

  • dispatch_async 异步： 当前线程会继续执行，不会阻塞当前线程

  • dispatch_sync 同步： 阻塞当前线程 等待block中的任务执行完毕

  • tips：有人说async和sync的区别是是否会另开线程，这样说是不严谨的，在下文常见问题中会详述

  • 常见问题：

  • 主队列异步

NSLog(@"1");
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"2");
    });
    NSLog(@"3");

打印结果：132
然而这样貌似并不清晰，再来看下面

 NSLog(@"%@", [NSThread currentThread]);
NSLog(@"1");
    dispatch_async(dispatch_get_main_queue(), ^{
        
        [NSThread sleepForTimeInterval:2.0f];
        NSLog(@"%@", [NSThread currentThread]);
        NSLog(@"2");
    });
    [NSThread sleepForTimeInterval:2.0f];
    NSLog(@"%@", [NSThread currentThread]);
    NSLog(@"3");

打印结果：

SomeThing[47574:2035090] <NSThread: 0x7fdebbd04e30>{number = 1, name = main}
SomeThing[47574:2035090] 1
SomeThing[47574:2035090] <NSThread: 0x7fdebbd04e30>{number = 1, name = main}
SomeThing[47574:2035090] 3
SomeThing[47574:2035090] <NSThread: 0x7fdebbd04e30>{number = 1, name = main}
SomeThing[47574:2035090] 2

结论：主队列异步，没有另开线程，所以在主队列中，即使有异步操作，主队列依然会遵循FIFO原则在主线程串行执行（上文说到同步与异步的区别是是否开启新线程这一说法不严谨，这里我们可以看到，异步不一定会开启新线程，看完下面几个例子，还会验证同步一定会阻塞当前线程）

  • 全局队列异步
NSLog(@"1");    
  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"2");
    });    
    NSLog(@"3");

打印结果：132
再来看下面：

NSLog(@"%@", [NSThread currentThread]);
    NSLog(@"1");
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"%@", [NSThread currentThread]);
        NSLog(@"2");
    });
    
    [NSThread sleepForTimeInterval:2.0f];
    NSLog(@"%@", [NSThread currentThread]);
    NSLog(@"3");

打印结果：

SomeThing[47614:2040514] <NSThread: 0x7fa70b6017a0>{number = 1, name = main}
SomeThing[47614:2040514] 1
SomeThing[47614:2040554] <NSThread: 0x7fa70b52bb50>{number = 2, name = (null)}
SomeThing[47614:2040554] 2
SomeThing[47614:2040514] <NSThread: 0x7fa70b6017a0>{number = 1, name = main}
SomeThing[47614:2040514] 3

结论：全局队列异步，另开线程，2、3执行顺序理论上是不确定的

  • 主队列同步
NSLog(@"1");
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"2");
    });
    NSLog(@"3");

打印结果：1
结论：线程死锁，因为同步任务有一个特点就是添加即立即执行，此时主队列还有3没有执行，主线程又会因为同步任务等待主队列调度任务，主队列等待分配同步任务，而同步任务之前，主队列还有任务没有执行，这种相互等待就会造成线程死锁，主线程的死锁结果是UI卡死

  • 全局队列同步
NSLog(@"%@", [NSThread currentThread]);
    NSLog(@"1");
    
    dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [NSThread sleepForTimeInterval:2.0f];
        NSLog(@"%@", [NSThread currentThread]);
        NSLog(@"2");
    });
    
    [NSThread sleepForTimeInterval:2.0f];
    NSLog(@"%@", [NSThread currentThread]);
    NSLog(@"3");

打印结果：

SomeThing[2891:278388] <NSThread: 0x7f82b1d06c00>{number = 1, name = main}
SomeThing[2891:278388] 1
SomeThing[2891:278388] <NSThread: 0x7f82b1d06c00>{number = 1, name = main}
SomeThing[2891:278388] 2
SomeThing[2891:278388] <NSThread: 0x7f82b1d06c00>{number = 1, name = main}
SomeThing[2891:278388] 3

结论：阻塞当前线程(主线程)先执行block内任务，此处代码与主队列同步非常相似，区别仅在于主队列和全局队列，而这里为什么不会造成线程死锁呢？很简单，一步一步来分析，因为这里不会造成“相互等待”，同步任务添加至全局异步队列并立即执行，主队列等待同步任务执行结束，回到主队列继续执行任务3。会造成困惑往往是因为在不经意间把主队列与主线程混淆了。

  • 组合问题一
dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"1"); 
        dispatch_sync(dispatch_get_main_queue(), ^{
            NSLog(@"%@", [NSThread currentThread]);
            [NSThread sleepForTimeInterval:2];
            NSLog(@"2"); 
        });
        NSLog(@"3"); 
    });
    NSLog(@"4");

结果：4123或1423
分析：
1）异步操作1和4都有可能先完成，注意在实际开发中的大段代码中我们要注意到4的存在
2）多线程开发中要时时刻刻确认当前线程是什么，1->2或4->2主队列同步，主队列任务一定会回到主线程执行，所以当前线程由子线程回到主线程
3）同步一定会阻塞当前线程，这里的当前线程是回到主线程之前的子线程，所以2->3
4）这里的主线程同步依然不会造成死锁，为什么呢？因为线程死锁的根本原因是“相互等待”，而这里，等待同步任务的线程是线程2，而不是主线程，所以不会造成死锁。

  • 组合问题二
dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"1"); // 任务1
        dispatch_sync(dispatch_get_main_queue(), ^{
            NSLog(@"2"); // 任务2
        });
        NSLog(@"3"); // 任务3
    });
    NSLog(@"4"); // 任务4
    while (1) {}
    NSLog(@"5"); // 任务5

结果：14或41
分析：while()循环会直接导致死锁

  • 总结：关于GCD中这几个典型问题的分析，只要把握几个原则就可以清晰的理解了，首先，串行队列一定遵循FIFO原则；然后，明确线程和队列的概念，线程是线程，队列是队列；还有，一定要明确当前线程是什么；最后，明确串行队列和并发队列的区别，是否阻塞当前线程，是否会开启新线程。
  • 子线程回到主线程
dispatch_async( dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 执⾏耗时的异步操作...
        dispatch_async(dispatch_get_main_queue(), ^{
            // 回到主线程,执⾏UI刷新操作
        });
    });
  • 延迟执行
    1 NSObject方法
[self performSelector:@selector(run) withObject:nil afterDelay:2.0];

注意点：该方法在哪个线程调用，就在那个线程执行
2 GCD函数

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // 2秒后异步执行这里的代码...
});

注意点：dispatch_after可以通过指定队列来控制在哪个线程执行，主队列就在主线程，并发队列就新开线程

  • 一次性代码
    在程序运行中只会执行一次
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    // 只执行1次的代码(这里面默认是线程安全的)
});

GCD实现的单例模式

//初始化
-(instancetype)init{
    // 只进行一次
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _instance = [super init];
    });
    return _instance;
}
//调用
+(instancetype)sharedSingleton{
 return [[self alloc] init];
}
//copy底层会调用copyWithZone
-(id)copyWithZone:(NSZone *)zone{ 
return _instance;
}
  • dispatch_group_async
    dispatch_group_async可以实现对一组并发任务的监听，比如10个并发任务，全部完成后回到主线程进行下一步：
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_t group = dispatch_group_create();
    
    for (int i = 0; i < 10; i++) {
        dispatch_group_async(group, queue, ^{
            [NSThread sleepForTimeInterval:i];
            NSLog(@"-%d", i);
        });
    }
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        //更新界面
    });
  • 队列组

NSThread：

NSOpreation

NSOperation 是苹果公司对 GCD 的封装，完全面向对象，所以使用起来更好理解。NSOperation和NSOperationQueue分别对应 GCD 的 任务 和 队列。

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

推荐阅读更多精彩内容

  • 多线程知识总结
    NSThread 第一种:通过NSThread的对象方法 NSThread *thread = [[NSThrea...
    攻城狮GG阅读 862评论 0赞 3
  • iOS多线程简析
    在这篇文章中，我将为你整理一下 iOS 开发中几种多线程方案，以及其使用方法和注意事项。当然也会给出几种多线程的案...
    张战威ican阅读 633评论 0赞 0
  • iOS多线程浅汇-实战篇
    一、前言 上一篇文章iOS多线程浅汇-原理篇中整理了一些有关多线程的基本概念。本篇博文介绍的是iOS中常用的几个多...
    nuclear阅读 2,079评论 6赞 18
  • 《摔跤吧，爸爸》
    这个电影真的非常火，为什么这么火？ 因为它源于生活，真真实实的生活励志片，两个女孩，从小被爸爸树立目标，当摔跤运动...
    Lily_a6cc阅读 207评论 0赞 0
  • 重重“霾”伏下插翅难逃，八方互助成守护屏障
    截至今日，京津冀地区雾霾的橙色预警已经亮灯数日，持续时间之久再创历史新高，重重“霾”伏下的北京城到底还有没有出路？...
    互帮互助阅读 179评论 0赞 0