一个java程序员自学IOS开发之路（十三）

2015/12/09

Day 46

今天学习多线程

多线程的优缺点

• 优点
1. 充分发挥多核处理器优势，将不同线程任务分配给不同的处理器，真正进入“并行运算”状态
2. 将耗时的任务分配到其他线程执行，由主线程负责统一更新界面会使应用程序更加流畅，用户体验更好
3. 当硬件处理器的数量增加，程序会运行更快，而程序无需做任何调整
• 缺点

  新建线程会消耗内存空间和CPU时间，线程太多会降低系统的运行性能

iOS的三种多线程技术

• NSThread 
1. 使用NSThread对象建立一个线程非常方便
2. 但是！要使用NSThread管理多个线程非常困难，不推荐使用
3. 技巧！使用[NSThread currentThread]跟踪任务所在线程，适用于这三种技术
• NSOperation/NSOperationQueue
1. 是使用GCD实现的一套Objective-C的API
2. 是面向对象的线程技术
3. 提供了一些在GCD中不容易实现的特性，如：限制最大并发数量、操作之间的依赖关系
• GCD —— Grand Central Dispatch 
1. 是基于C语言的底层API
2. 用Block定义任务，使用起来非常灵活便捷
3. 提供了更多的控制能力以及操作队列中所不能使用的底层函数
• 提示：iOS的开发者，需要了解三种多线程技术的基本使用，因为在实际开发中会根据实际情况选择不同的多线程技术

GCD基本思想

• GCD的基本思想是就将操作s放在队列s中去执行
1. 操作使用Blocks定义（Swift里用闭包）
2. 队列负责调度任务执行所在的线程以及具体的执行时间
3. 队列的特点是先进先出(FIFO)的，新添加至对列的操作都会排在队尾
• 提示

GCD的函数都是以dispatch(分派、调度)开头的

• 队列

dispatch_queue_t 

• 串行队列，队列中的任务只会顺序执行
• 并行队列，队列中的任务通常会并发执行
• 操作

dispatch_async 异步操作，会并发执行，无法确定任务的执行顺序

dispatch_sync 同步操作，会依次顺序执行，能够决定任务的执行顺序

 

下面是演练GCD的OC代码

串行队列（一个接一个，排队跑步，保持队形）

    NSLog(@"%@", [NSThread currentThread]);
    dispatch_queue_t q = dispatch_queue_create(“yu1”, DISPATCH_QUEUE_SERIAL);
    // 非ARC开发时，千万别忘记release
    //    dispatch_release(q);
    
    // 串行行队列的同步任务，同样会在主线程上运行
    // 提示：在开发中极少用
    for (int i = 0; i < 5; ++i) {
        // 同步任务顺序执行
        dispatch_sync(q, ^{
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
    
    for (int i = 0; i < 5; ++i) {
        // 异步任务，并发执行，但是如果在串行队列中，仍然会依次顺序执行
        dispatch_async(q, ^{
            // [NSThread currentThread] 可以在开发中，跟踪当前线程
            // num = 1，表示主线程
            // num = 2，表示第2个子线程。。。
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }

打印结果如下

 

然后是并行队列（并排跑，类似于赛跑）

    NSLog(@"%@", [NSThread currentThread]);
    // 特点：没有队形，执行顺序程序员不能控制！
    // 应用场景：并发执行任务，没有先后顺序关系
    // 并行队列容易出错！并行队列不能控制新建线程的数量！
    dispatch_queue_t q = dispatch_queue_create("yu2", DISPATCH_QUEUE_CONCURRENT);
    
    for (int i = 0; i < 10; ++i) {
        // 异步任务
        dispatch_async(q, ^{
            // [NSThread currentThread] 可以在开发中，跟踪当前线程
            // num = 1，表示主线程
            // num = 2，表示第2个子线程。。。
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
    
    for (int i = 0; i < 10; ++i) {
        // 同步任务顺序执行
        dispatch_sync(q, ^{
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }

控制台打印

 

注意：关于多线程不要只看一次运行结果，像上面的代码，多运行几次结果是不一样的

 

全局队列（苹果为了方便多线程的设计，提供一个全局队列，供所有的APP共同使用）

    // 全局队列与并行队列的区别
    // 1> 不需要创建，直接GET就能用
    // 2> 两个队列的执行效果相同
    // 3> 全局队列没有名称，调试时，无法确认准确队列
    NSLog(@"%@", [NSThread currentThread]);
    // 优先级在开发中一般用DISPATCH_QUEUE_PRIORITY_DEFAULT
    dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    for (int i = 0; i < 5; ++i) {
        // 同步任务顺序执行
        dispatch_sync(q, ^{
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
    
    for (int i = 0; i < 5; ++i) {
        dispatch_async(q, ^{
            // [NSThread currentThread] 可以在开发中，跟踪当前线程
            // num = 1，表示主线程
            // num = 2，表示第2个子线程。。。
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }

打印如下

 

主(线程)队列，保证操作在主线程上执行

    // 每一个应用程序都只有一个主线程
    // 为什么需要在主线程上工作呢？
    // 在iOS开发中，所有UI的更新工作，都必须在主线程上执行！
    dispatch_queue_t q = dispatch_get_main_queue();
    
    // 主线程是有工作的，而且除非将程序杀掉，否则主线程的工作永远不会结束！
    // 同步任务，阻塞了！！！
   // dispatch_sync(q, ^{
   //     NSLog(@"come here baby!");
   //});
    
    // 异步任务，在主线程上运行，同时是保持队形的
    for (int i = 0; i < 5; ++i) {
        dispatch_async(q, ^{
            NSLog(@"%@ - %d", [NSThread currentThread], i);
        });
    }

注意阻塞情况，打印如下

 

接下来用swift将上面4个demo演练了一遍

串行队列（一个接一个，排队跑步，保持队形）

        let q = dispatch_queue_create("串行队列1", DISPATCH_QUEUE_SERIAL)
        print("串行队列，同步任务")
        for i in 0 ..< 5 {
            //同步任务，顺序执行，同一线程上执行(还是在主线程)
            dispatch_sync(q, { () -> Void in
                print("(NSThread.currentThread()) - (i)")
            })
        }
        print("串行队列，异步任务")
        for i in 0 ..< 5 {
            //异步任务，开一个子线程并发执行，但是如果在串行队列中，仍然会依次顺序执行
            // num = 1，表示主线程
            // num = 2，表示第2个子线程。。。
            dispatch_async(q, { () -> Void in
                print("(NSThread.currentThread()) - (i)")
            })
        }        

控制台打印

 

并行队列（并排跑，类似于赛跑）

        // 特点：没有队形，执行顺序程序员不能控制！
        // 应用场景：并发执行任务，没有先后顺序关系
        // 并行队列容易出错！并行队列不能控制新建线程的数量！
        let q = dispatch_queue_create("并行队列1", DISPATCH_QUEUE_CONCURRENT)
        
        print("并行队列，异步任务")
        for i in 0 ..< 5 {
            //异步任务，随机乱序，并且有N个子线程
            dispatch_async(q, { () -> Void in
                print("(NSThread.currentThread()) - (i)")
            })
        }
        
        print("并行队列，同步任务")
        for i in 0 ..< 5 {
            //同步任务，顺序执行，同一线程上执行(还是在主线程)
            dispatch_sync(q, { () -> Void in
                print("(NSThread.currentThread()) - (i)")
            })
        }

控制台打印

 

全局队列（苹果为了方便多线程的设计，提供一个全局队列，供所有的APP共同使用）

        // 全局队列与并行队列的区别
        // 1> 不需要创建，直接GET就能用
        // 2> 两个队列的执行效果相同
        // 3> 全局队列没有名称，调试时，无法确认准确队列
        
        // 优先级在开发中一般用DISPATCH_QUEUE_PRIORITY_DEFAULT
        let q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
        
        print("全局队列，异步任务")
        for i in 0 ..< 5 {
            //异步任务，随机乱序，并且有N个子线程
            dispatch_async(q, { () -> Void in
                print("(NSThread.currentThread()) - (i)")
            })
        }
        
        print("全局队列，同步任务")
        for i in 0 ..< 5 {
            //同步任务，顺序执行，同一线程上执行(还是在主线程)
            dispatch_sync(q, { () -> Void in
                print("(NSThread.currentThread()) - (i)")
            })
        } 

控制台打印

 

主(线程)队列，保证操作在主线程上执行

 

        // 每一个应用程序都只有一个主线程
        // 为什么需要在主线程上工作呢？
        // 在iOS开发中，所有UI的更新工作，都必须在主线程上执行！
        let q = dispatch_get_main_queue()
        
        print("主队列，异步任务")
        for i in 0 ..< 5 {
            // 异步任务，在主线程上运行，同时是保持队形的
            dispatch_async(q, { () -> Void in
                print("(NSThread.currentThread()) - (i)")
            })
        }
        
//        print("主队列，同步任务，阻塞")
//        // 主线程是由工作的，而且除非将程序杀掉，否则主线程的工作永远不会结束！
//        // 阻塞了！！！
//        dispatch_sync(q, { () -> Void in
//            print("come on baby")
//        })        

控制台打印

 

dispatch_sync的应用场景

• 阻塞并行队列的执行，要求某一操作执行后再进行后续操作，如用户登录
• 确保块代码之外的局部变量确实被修改

dispatch_queue_t q = dispatch_queue_create(“yu3”, DISPATCH_QUEUE_CONCURRENT);
__block BOOL logon = NO;
dispatch_sync(q, ^{
    NSLog(@"模拟耗时操作 %@", [NSThread currentThread]);
      [NSThread sleepForTimeInterval:2.0f];//通常在多线程调试中用于模拟耗时操作, 在发布的应用程序中，不要使用此方法！
    NSLog(@"模拟耗时完成 %@", [NSThread currentThread]); 
    logon = YES;
});

dispatch_async(q, ^{
       NSLog(@"登录完成的处理 %@", [NSThread currentThread]);
});

GCD小结

串行队列，同步任务，不需要新建线程

串行队列，异步任务，需要一个子线程，线程的创建和回收不需要程序员参与！

“是最安全的一个选择”串行队列只能创建一个子线程

 

并行队列，同步任务，不需要创建线程

并行队列，异步任务，有多少个任务，就开N个线程执行，

 

无论什么队列和什么任务，线程的创建和回收不需要程序员参与。

线程的创建回收工作是由队列负责的

 

“并发”编程，为了让程序员从负责的线程控制中解脱出来！只需要面对队列和任务！

• GCD
1. 通过GCD，开发者不用再直接跟线程打交道，只需要向队列中添加代码块即可
2. GCD在后端管理着一个线程池，GCD不仅决定着代码块将在哪个线程被执行，它还根据可用的系统资源对这些线程进行管理。从而让开发者从线程管理的工作中解放出来，通过集中的管理线程，缓解大量线程被创建的问题
3. 使用GCD，开发者可以将工作考虑为一个队列，而不是一堆线程，这种并行的抽象模型更容易掌握和使用

 

• GCD的队列
1. GCD公开有5个不同的队列：运行在主线程中的主队列，3 个不同优先级的后台队列，以及一个优先级更低的后台队列（用于 I/O）
2. 自定义队列：串行和并行队列。自定义队列非常强大，建议在开发中使用。在自定义队列中被调度的所有Block最终都将被放入到系统的全局队列中和线程池中
3. 提示：不建议使用不同优先级的队列，因为如果设计不当，可能会出现优先级反转，即低优先级的操作阻塞高优先级的操作

GCD队列示意图

  

NSOperation & NSOperationQueue

• 简介
• NSOperationQueue(操作队列)是由GCD提供的队列模型的Cocoa抽象，是一套Objective-C的API
• GCD提供了更加底层的控制，而操作队列则在GCD之上实现了一些方便的功能，这些功能对于开发者而言通常是最好最安全的选择
• 队列及操作
• NSOperationQueue有两种不同类型的队列：主队列和自定义队列
• 主队列运行在主线程上
• 自定义队列在后台执行
• 队列处理的任务是NSOperation的子类
1. NSInvocationOperation
2. NSBlockOperation

 

NSOperation的基本使用步骤

1. 定义操作队列
2. 定义操作
3. 将操作添加到队列

提示：一旦将操作添加到队列，操作就会立即被调度执行

 

NSInvocationOperation(调度操作)

• //定义队列
  self.myQueue = [[NSOperationQueue alloc] init];
  //操作调用的方法
  - (void)operationAction:(id)obj
  {
      NSLog(@"%@ - obj : %@", [NSThread currentThread], obj);
  }
  //定义操作并添加到队列
  NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(operationAction:) object:@(i)];
  [self.myQueue addOperation:op];
  //小结：需要准备一个被调度的方法，并且能够接收一个参数，使用起来不方便

NSBlockOperation

//定义操作并添加到队列
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
    [self operationAction:@"Block Operation"];
}];
//将操作添加到队列
[self.myQueue addOperation:op];

设置操作的依赖关系(顺序执行)

NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"%@ - 下载图片", [NSThread currentThread]);
}];
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"%@ - 添加图片滤镜", [NSThread currentThread]);
}];
NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"%@ - 更新UI", [NSThread currentThread]);
}];
[op2 addDependency:op1];
[op3 addDependency:op2];
[self.myQueue addOperation:op1];
[self.myQueue addOperation:op2];
[[NSOperationQueue mainQueue] addOperation:op3];

提示：利用addDependency可以指定操作之间的彼此依赖关系(执行先后顺序)

注意：不要出现循环依赖！

 

NSOperationQueue还可以设置同时并发的线程数量

[self.myQueue setMaxConcurrentOperationCount:3];

设置同时并发的线程数量能够有效地降低CPU和内存的开销

这一功能用GCD不容易实现

 

Run Loop

(1) Run Loop提供了一种异步执行代码的机制，不能并行执行任务

(2) 在主队列中，Main Run Loop直接配合任务的执行，负责处理UI事件、计时器，以及其它内核相关事件

(3) Run Loop的主要目的是保证程序执行的线程不会被系统终止

Run Loop的工作特点

1. 当有事件发生时，Run Loop会根据具体的事件类型通知应用程序做出响应
2. 当没有事件发生时，Run Loop会进入休眠状态，从而达到省电的目的
3. 当事件再次发生时，Run Loop会被重新唤醒，处理事件

主线程和其他线程中的Run Loop

• iOS程序的主线程默认已经配置好了Run Loop
• 其他线程默认情况下没有设置Run Loop
• 一般在开发中很少会主动创建RunLoop，而通常会把事件添加到RunLoop中

 

多线程中的资源共享

并发编程中许多问题的根源就是在多线程中访问共享资源。资源可以是一个属性、一个对象、网络设备或者一个文件等

在多线程中任何一个共享的资源都可能是一个潜在的冲突点，必须精心设计以防止这种冲突的发生

 

为了保证性能，atomic仅针对属性的setter方法做了保护

而争抢共享资源时，如果涉及到属性的getter方法，可以使用互斥锁@synchronized可以保证属性在多个线程之间的读写都是安全的

无论是atomic还是@synchronized，使用的代价都是高昂的，不建议使用

 

建议：多线程是并发执行多个任务提高效率的，如果可能，应该在线程中避免争抢共享资源

 

正是出于性能的考虑，UIKit中的绝大多数的类都不是线程安全的，因此，苹果公司要求：更新UI相关的操作，应该在主线程中执行

 

单例模式

• 单例模式是一种常用的软件设计模式
• 通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源
• 如果希望系统中某个类的对象只能存在一个，单例模式是最好的解决方案
• iOS中最常见的单例就是UIApplication 
• 应用场景：

音频播放，背景音乐！

硬件资源：加速器、[UIScreen mainScreen]

下面是实现单例模式的OC代码

DemoObj.h

@interface DemoObj : NSObject

+ (instancetype)sharedDemoObj;

@end

DemoObj.m

@implementation DemoObj
/**
 1. 重写allocWithZone，用dispatch_once实例化一个静态变量(dispatch_once是线程安全的,能够做到在多线程的环境下Block中的代码只会被执行一次)
 2. 写一个+sharedXXX方便其他类调用
 */
// 在OC中，所有对象的内存空间的分配，最终都会调用allocWithZone方法
// 如果要做单例，需要重写此方法
// GCD提供了一个方法，专门用来创建单例的
+ (instancetype)allocWithZone:(struct _NSZone *)zone {
    static DemoObj *result;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        result = [super allocWithZone:zone];
    });
    return result;
}

+ (instancetype)sharedDemoObj {
    return [[self alloc] init];
}
@end

Swift代码

class Singleton: NSObject {
    internal class func sharedInstance() -> Singleton {
        struct Static {
            static var onceToken : dispatch_once_t = 0
            static var instance : Singleton? = nil
        }
        dispatch_once(&Static.onceToken) {
            Static.instance = Singleton()
        }
        return Static.instance!
    }
}

单例小结

优点: 可以阻止其他对象实例化单例对象的副本，从而确保所有对象都访问唯一实例

缺点: 单例对象一旦建立，对象指针是保存在静态区的，单例对象在堆中分配的内存空间，会在应用程序终止后才会被释放

提示: 只有确实需要唯一使用的对象才需要考虑单例模式，不要滥用单例

 

NSObject的多线程方法

• 开启后台执行任务的方法

- (void)performSelectorInBackground:(SEL)aSelector withObject:(id)arg

• 在后台线程中通知主线程执行任务的方法

- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait

• 获取线程信息

[NSThread currentThread]

• 线程休眠

[NSThread sleepForTimeInterval:2.0f];

• 特点

使用简单，量级轻

不能控制线程的数量以及执行顺序

注意事项

NSObject的多线程方法使用的是NSThread的多线程技术

而NSThread的多线程技术不会自动使用@autoreleasepool

在使用NSObject或NSThread的多线程技术时，如果涉及到对象分配，需要手动添加@autoreleasepool

 

复习一下autoreleasepool

iOS开发中的内存管理

• 在iOS开发中，并没有JAVA或C#中的垃圾回收机制
• 使用ARC开发，只是在编译时，编译器会根据代码结构自动添加了retain、release和autorelease

 

自动释放池的工作原理

• 标记为autorelease的对象在出了作用域范围后，会被添加到最近一次创建的自动释放池中
• 当自动释放池被销毁或耗尽时，会向自动释放池中的所有对象发送release消息

 

每个线程都需要有@autoreleasepool，否则可能会出现内存泄漏，但是使用NSThread多线程技术，并不会为后台线程创建自动释放池