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

作者: 王蓝胖 | 来源:发表于2016-09-20 16:12 被阅读174次

iOS开发中的多线程技术(待续)
iOS文章 - 收藏集 - 掘金
iOS多线程：GCD详解
iOS多线程：NSOperation详解
2019-08-07 iOS多线程开发
iOS多线程详解
iOS多线程--并行开发一
GCD
《Objective-C 高级编程》干货三部曲（三）：GCD篇
GCD

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 的任务和队列。

iOS开发中的多线程技术(待续)
GCD：特点：自动管理线程的生命周期（创建线程、调度任务、销毁线程），使用C语言，自带Block。灵活，方便，功...
iOS文章 - 收藏集 - 掘金
iOS 开发 - 多线程陷阱 - iOS - 掘金前言随着手机硬件的升级，多线程技术在应用开发中的地位可以说足以...
iOS多线程：GCD详解
多线程开发是日常开发任务中不可缺少的一部分，在iOS开发中常用到的多线程开发技术有GCD、NSOperation、...
iOS多线程：NSOperation详解
多线程开发是日常开发任务中不可缺少的一部分，在iOS开发中常用到的多线程开发技术有GCD、NSOperation、...
2019-08-07 iOS多线程开发
iOS开发常常会碰到多线程开发技术，我们常用的集中多线程开发的技术有一下几点：（1）pThread进行开发，pth...
iOS多线程详解
在iOS开发中，我们经常会使用到多线程技术，用于处理一些比较耗时的操作。在iOS中，有四种多线程的API，接下...
iOS多线程--并行开发一
iOS多线程--并行开发二重点分析iOS多线程开发：iOS多线程:在iOS中每个进程启动后都会建立一个主线程（U...
GCD
在iOS开发中，一共有四种多线程技术：pthread，NSThread，GCD，NSOperation： pthr...
《Objective-C 高级编程》干货三部曲（三）：GCD篇
我们知道在iOS开发中，一共有四种多线程技术：pthread，NSThread，GCD，NSOperation： ...
GCD
我们知道在iOS开发中，一共有四种多线程技术：pthread，NSThread，GCD，NSOperation： ...