多线程学习笔记-01

• 多线程概念
• NSThread：基本使用 现成状态 资源抢夺 互斥锁&原子属性 线程间通讯
• GCD：队列&任务 GCD常用代码&队列的选择 其他功能（延时，一次性执行，分组）
• NSOperation:简单使用 其他功能（最大并发数，队列的暂停&继续，任务的依赖关系） 网络图像加载实现（无沙盒缓存，沙盒缓存，SDWebImage实现原理）

多线程基础

什么是进程？

• 进程是指系统中正在运行的一个应用程序
• 每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内

什么是线程

• 1个进程要想执行任务，必须得有线程（每个进程至少要有1条线程）
• 线程是进程的基本执行单元，一个进程（程序）的所有任务都在线程中执行

比如使用酷我音乐、使用迅雷下载电影，都需要在线程中执行

线程的串行

1个线程中任务的执行是串行（顺序执行）的
如果要在1个线程中执行多个任务，那么只能一个一个地按顺序执行这些任务
也就是说，在同一时间内，1个线程只能执行一个任务

比如在1个线程中下载3个文件（分别是文件A,文件B，文件C）

因此，也可以认为线程是进程中的1条执行路径

多线程

1.什么是多线程？
1个进程中可以开启多条线程，每条线程可以并发（同时）执行不同的任务
进程 -> 车间，线程 -> 车间工人
多线程技术可以提高程序的执行效率

比如同时开启3条线程分别下载3个文件（分别是文件A，文件B，文件C）

2.多线程的原理
同一时间，CPU只能处理1条线程，只有1条线程在工作（执行）
多线程并发（同时）执行，其实是CPU快速地在多条线程之间调度（切换）
如果CPU调度线程的时间足够快，就造成了多线程并发执行的假象

思考：如果线程非常非常多，会发生什么情况？
CPU会在N多线程之间调度，CPU会累死，消耗大量的CPU资源
每条线程被调度执行的频次会降低（线程的执行效率降低）

多线程的优缺点

1.多线程的优点
能适当提高程序的执行效率
能适当提高资源的利用率（CPU,内存利用率）

2.多线程的缺点
开启线程需要占用一定的内存空间（默认情况下，主线程占用1M，子线程占用512K），如果开启大量的线程，会占用大量的内存空间，降低程序的性能
线程越多，CPU在调度线程上的开销就越大
程序设计更加复杂：比如线程之间的通信、多线程的数据共享

多线程在iOS开发中的应用

1.什么是主线程？

一个iOS程序运行后，默认会开启1条线程，成为“主线程”或“UI线程”

2.主线程的主要作用
显示/刷新UI界面
处理UI事件（比如点击事件、滚动事件、拖拽事件等）

3.主线程的使用注意
别将比较耗时的操作放到主线程中
耗时操作会卡住主线程，严重影响UI的流畅度，给用户一种“卡”的坏体验

如果将耗时操作放在主线程

4.耗时操作的执行

如果将耗时操作放在子线程（后台线程，非主线程）

iOS中多线程的实现方案

NSThread的创建

三种创建线程方式

- (void)test1
{
    // 实例化一个线程对象
    NSThread * thread = [[NSThread alloc] initWithTarget:self selector:@selector(run:) object:nil];

    //让线程开始工作，启动线程,在新开的线程中执行run方法
    [thread start];
}

- (void)test2
{
    NSLog(@"%@",[NSThread currentThread]);
    [NSThread detachNewThreadSelector:@selector(run:) toTarget:self withObject:@"hello"];
    NSLog(@"test1 ---- %@",[NSThread currentThread]);
}

- (void)test3
{
    // "隐式"创建线程方法
    [self performSelectorInBackground:@selector(run:) withObject:@"hello"];
}

线程的属性

name:可以给NSThread的对象设置name属性，这个属性在当程序有bug打印log时，帮主我们识别是哪个线程中出了问题
threadPriority：优先级，介于0.0~1.0之间，默认值0.5，优先级高的会优先执行。但是在测试时哪个线程优先体现得不是很明显，多次测试可以观察到。

#pragma mark - 线程的属性
- (void)test4
{
    NSThread * threadA = [[NSThread alloc] initWithTarget:self selector:@selector(run:) object:@"hello"];
    // 给thread设置name属性，可以在程序出bug时打印的log里面看出是哪个线程的问题。
    threadA.name = @"thread A";
    //线程优先级
    // 是一个浮点数，0.0~1.0.默认值0.5
    // 开发的时候，一般不去修改优先级的值。
    // 优先级，必须调用很多次的时候，才能体现出来
    threadA.threadPriority = 0.1;
    //开始工作
    [threadA start];
    NSThread * threadB = [[NSThread alloc] initWithTarget:self selector:@selector(run:) object:@"hello"];
    threadB.name = @"thread B";
    //线程优先级
    // 是一个浮点数，0.0~1.0.默认值0.5
    threadB.threadPriority = 1.0;
    //开始工作
    [threadB start];
}

线程的状态

• 新建一个线程，被放进一个可调度线程池中（这个线程池中有新建的线程以及其他线程）
• start之后进入就绪状态（Runnable）,随时可被CPU调度
• CPU调度之后进入运行（Running）状态，如果CPU调度其他线程，则新建线程进入就绪状态
• 如果线程在运行中，被调用了sleep方法或者等待同步锁，则进入阻塞（blocked）状态，阻塞状态下线程被从可调度线程池中移除，CPU不会调用可调度线程池之外的线程。sleep到时或者得到同步锁，线程再次进入就绪状态，即进入可调度线程池
• 线程任务执行完毕或者异常、强制退出时，线程死亡（dead），就从内存中被销毁

控制线程状态

1.启动线程

- (void)start;

//进入就绪状态->运行状态。当线程任务执行完毕，自动进入死亡状态

2.阻塞（暂停）线程

- (void)sleepUntilData:(NSDate*)date;

- (void)sleepForTimeInterval:(NSTimeInteval)ti;

//进入阻塞状态
3.强制停止线程

+(void)exit;

//进入死亡状态

注意：一旦线程停止（死亡）了，就不能再次开启任务

示例代码：

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
    [self test];
}
- (void)test
{
    //1.新建一个线程
    NSThread * thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];

    //2.放进一个可调度线程池，等待被调度。就绪状态
    [thread start];

}

- (void)run
{
    NSLog(@"%s",__func__);
    //刚进来就睡会
  //  [NSThread sleepForTimeInterval:2.0];
    // 睡到指定的时间点
   // [NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:5.0]];
    for(int i = 0;i < 20; i++){
        //满足某一个条件以后，阻塞线程的执行.也就是让线程休息一会
        if(i == 10){
            [NSThread sleepForTimeInterval:3.0];
        }
        //一旦达到某一个条件，就强制终止线程的执行
        if(i == 15){
            //一旦强制终止，就再也不能重新启动了
            //一旦强制终止，后面的代码都不会执行了。
            [NSThread exit];
        }
        NSLog(@"%@ ----- %d",[NSThread currentThread],i);
    }
    NSLog(@"线程结束"); // 线程退出之后这句代码就执行不到了
}

多线程的安全隐患

1.资源共享
1块资源可能会被多个线程共享，也就是多个线程可能会访问同一块资源
比如多个线程访问同一个对象、同一个变量、同一个文件
当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题
安全隐患示例-01

安全隐患示例02-卖票

示例代码

#import "ViewController.h"

@interface ViewController ()
/**
 总票数
 */
@property(nonatomic, assign)int tickets;
@end

@implementation ViewController

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event{
    //剩余20张票
    self.tickets = 20;
    //主线程工作
  //  [self saleTickets];
    //增加子线程，卖票
    NSThread * threadA = [[NSThread alloc] initWithTarget:self selector:@selector(saleTickets) object:nil];
    threadA.name = @"售票员A";
    [threadA start];
    NSThread * threadB = [[NSThread alloc] initWithTarget:self selector:@selector(saleTickets) object:nil];
    threadB.name = @"售票员B";
    [threadB start];
}

#pragma mark - 卖票
/**
 1.开发比较复杂的多线程程序时，可以先再主线程把功能实现
 2.实现功能以后，可以把耗时的功能再放到子线程。
 3.再增加一个线程，建议开发的时候，线程一个一个增加
 */
- (void)saleTickets
{
    while (YES) {
        //模拟一下延时，卖一张休息1秒
       // [NSThread sleepForTimeInterval:1.0];
        //1.判断是否有余票
        if(self.tickets > 0){
            //2.如果有票，就卖一张
            self.tickets--;
            NSLog(@"剩余的票数 --- %d ---- %@",self.tickets,[NSThread currentThread]);
        }else{
            //3.如果没有就返回
            NSLog(@"没票了");
            break;
        }
    }
}
@end

运行结果

安全隐患分析

安全隐患解决 - 互斥锁

示例代码：

#import "ViewController.h"

@interface ViewController ()
/**
 总票数
 */
@property(nonatomic, assign)int tickets;
@end

@implementation ViewController

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event{

    //剩余20张票
    self.tickets = 20;

    //主线程工作
  //  [self saleTickets];

    //增加子线程，卖票
    NSThread * threadA = [[NSThread alloc] initWithTarget:self selector:@selector(saleTickets) object:nil];
    threadA.name = @"售票员A";
    [threadA start];

    NSThread * threadB = [[NSThread alloc] initWithTarget:self selector:@selector(saleTickets) object:nil];
    threadB.name = @"售票员B";
    [threadB start];

}

#pragma mark - 卖票
/**
 1.开发比较复杂的多线程程序时，可以先再主线程把功能实现
 2.实现功能以后，可以把耗时的功能再放到子线程。
 3.再增加一个线程，建议开发的时候，线程一个一个增加
 */

/**
 加锁，互斥锁
 加锁，锁定的代码尽量的少
 加锁范围内的代码，同一时间只允许一个线程执行
 互斥锁的参数：任何继承自NSObject *对象
 要保证这个锁，所有的线程都能访问到，并且所有线程访问的是同一个锁对象
 */
- (void)saleTickets
{
    while (YES) {
        //模拟一下延时，卖一张休息1秒
       // [NSThread sleepForTimeInterval:1.0];
      //  NSObject * obj = [[NSObject alloc] init];
        //为什么没有提示？因为苹果不推荐是用加锁。因为加锁，性能太差。
        @synchronized(self){ //开发的时候，一般就是用self就ok
            //1.判断是否有余票
            if(self.tickets > 0){
                //2.如果有票，就卖一张
                self.tickets--;
                NSLog(@"剩余的票数 --- %d ---- %@",self.tickets,[NSThread currentThread]);
            }else{
                //3.如果没有就返回
                NSLog(@"没票了");
                break;
            }
        }
    }
}
@end

1.互斥锁是用格式
@synchronized(锁对象){//需要锁定的代码}
注意：锁定一份代码只用1把锁，用多把锁是无效的
2.互斥锁的优缺点
优点：能有效防止因多线程抢夺资源造成的数据安全问题
缺点：需要消耗大量的CPU资源

3.互斥锁的是用前提：多条线程抢夺同一资源
4.相关专业术语：线程同步
线程同步的意思是：多条线程按顺序执行任务
互斥锁，就是使用了线程同步技术

原子属性&线程安全

@property (atomic,strong)NSObject * obj;

nonatomic:非原子属性
atomic:原子属性 – 默认属性
原子属性就是针对多线程设计的。原子属性实现单（线程）写多（线程）读
因为写的安全级别要求更高。读的要求低一些，可以多读几次来保证数据的正确性

atomic情况下，只要重写了set方法，getter也得重写

- (void)setObj:(NSObject *)obj
{
    // 原子属性内部使用的自旋锁
    // 自璇锁和互斥锁
    // 共同点：都可以锁定一段代码。同一时间，只有线程能够执行这段锁定的代码
    // 区别：互斥锁，在锁定的时候，其他线程会睡眠，等待条件满足，再唤醒
    // 自旋锁，在锁定的时候，其他的线程会做死循环，一直到等待条件满足，一旦条件满足，立马去执行，少了一个唤醒过程
    //互斥锁，
    @synchronized(self){ //模拟锁。真实情况下，使用的不是互斥锁
        _obj = obj;
    }
}

如果同时重写了setter和一个getter方法，”_成员变量”就不会提供,可以使用@synthesize合成指令,告诉编译器属性的成员变量的名称

@synthesize obj = _obj;
- (NSObject *)obj
{
    return _obj;
}

线程安全的概念
就是在多个线程同时执行的时候，能够保证资源信息的准确性

‘UI线程’ – 主线程
** UIKit 中绝大部分的类，都不是“线程安全”的
怎么解决这个线程不安全的问题？

苹果约定，所有程序的更新UI都在主线程进行，也就不会出现多个线程同时改变一个资源

在主线程更新UI，有什么好处
1.只在主线程更新UI，就不会出现多个线程同时改变 同一个UI控件
2.主线程的优先级最好。也就意味着UI的更新优先级高。会让用户感觉很流畅