多线程简介

1、关于线程的概念

学习多线程,是为了将一些耗时操作放到后台,以提高用户体验。

  • 进程
    进程可以理解成是系统中正在运行的一个应用程序。
    进程是系统进行资源分配和调度的基本单位。
    每个进程是独立的,每个进程均是运行在其专用且受保护的内存空间里。
  • 线程
    一个进程要想执行任务,必须得有线程(每个进程至少要有一条线程)
    线程是进程的基本执行单元,一个进程(程序)的所有任务都在线程中执行

也就是说,进程只是在内存中开辟了一个内存空间中而已,但是线程才是正真执行任务的

  • 线程的串行
    如果要在一个线程中执行多个任务,那么只能一个一个的按照顺序来执行这些任务,也就是说在同一时间内,1个线程只能执行一个任务
    因此,也可认为线程是进程中的一条执行路径。

  • 多线程
    1个进程中可以开启多条线程,每条线程可以并发(同时)执行不同的任务 ,多线程可以提高程序的执行效率,尤其是在下载的地方常用。
    类比:进程——车间 ,线程——车间工人

  • 多线程的原理
    同一时间,CPU只能处理一条线程,只有1条线程在工作(执行),但是CPU执行的速度是非常快的,能够快速的在多条线程时间调度(切换),切换到哪个线程,哪个线程就会执行一点。
    如果CPU调度线程的时间足够快,就造成了多线程并发执行的假象(其实只是在不同的线程之间切换而已)

  • 多线程的优点
    能适当提高程序的执行效率
    能适当提高资源利用率(CPU、内存利用率)

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

  • 什么是主线程
    一个iOS程序运行后,默认会开启1条线程,称为“主线程”或“UI线程”

  • 主线程的主要作用
    显示\刷新UI界面
    处理UI事件(比如点击事件、滚动事件、拖拽事件等)

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

2、线程的状态与生命周期
屏幕快照 2018-11-25 下午3.48.08.png

下面分别阐述线程生命周期中的每一步
新建:
实例化线程对象
就绪:
向线程对象发送start消息,线程对象被加入可调度线程池等待CPU调度。
运行:
CPU 负责调度可调度线程池中线程的执行。线程执行完成之前,状态可能会在就绪和运行之间来回切换。就绪和运行之间的状态变化由CPU负责,程序员不能干预。
阻塞:
当满足某个预定条件时,可以使用休眠或锁,阻塞线程执行。sleepForTimeInterval(休眠指定时长),sleepUntilDate(休眠到指定日期),@synchronized(self):(互斥锁)。
死亡:
正常死亡,线程执行完毕。非正常死亡,当满足某个条件后,在线程内部中止执行/在主线程中止线程对象
当死亡后,线程便从内存中消失了,不能重新被调用
线程的exit和cancel
[NSThread exit]:一旦强行终止线程,后续的所有代码都不会被执行。
[thread cancel]取消:并不会直接取消线程,只是给线程对象添加 isCancelled 标记。
注意:
线程的各种状态以及其转换的条件
线程在创建之后,只有在可调度线程池中,才能被调用,
当就绪、运行的状态下,线程存在于可调度线程池
当阻塞状态是,线程存在于内存中
当死亡后,线程便从内存中消失了,不能重新被调用

3、多线程的四种解决方案
屏幕快照 2018-11-24 下午5.53.03.png
  • <1>pthread 的用法
    pthread是C语言实现的方案,一般很少用
#import "ViewController.h"
#import <pthread.h>//需要导入头文件

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    //使用pthread创建线程 : pthread_create
    
    // pthread_create的参数说明:
    //参数1:线程变量
    //参数2:线程属性
    //参数3:线程要执行的函数(要在这个子线程中执行的任务)
    //参数4:执行任务需要的参数
    
    pthread_t threadId;//声明一个线程变量,第一个参数
    id str=@"hello"; //第四个参数,id需要转换成void *类型的,因为run方法里面是使用这种类型的参数的,所以使用使用__bridge 侨联
    pthread_create(&threadId, NULL, run, (__bridge void *)str);
}

//用作第3个属性参数
void *run(void *prama){   //void类型的不用return,但是void * 是一定要return的,void * 相当于oc 中的id
    NSString *str=(__bridge NSString *)(prama);
    for(int i=0;i<4;i++){
        NSLog(@"%@  %@" ,[NSThread currentThread],str);
    }
    return NULL;
}

@end

打印结果:
===============================================
pthread[1620:149861] <NSThread: 0x600001ca47c0>{number = 3, name = (null)}  hello
pthread[1620:149861] <NSThread: 0x600001ca47c0>{number = 3, name = (null)}  hello
pthread[1620:149861] <NSThread: 0x600001ca47c0>{number = 3, name = (null)}  hello
pthread[1620:149861] <NSThread: 0x600001ca47c0>{number = 3, name = (null)}  hello

number=1表示在主线程,number = 3表示当前线程是子线程
  • <2>NSThread的用法
    相较pthread来说,NSThread使用起来更简单快捷,但是无法对线程进行更详细的设置
#pragma mark -创建第一个线程
-(void)test1{
    //实例化一个线程对象,该方法有返回值,返回线程对象
    NSThread *thread=[[NSThread alloc] initWithTarget:self selector:@selector(run1) object:nil];
    //启动线程,在新开的线程中执行run方法
    [thread start];
}

-(void)run1{
    for (int i=0; i<4; i++) {
        NSLog(@"当前线程:%@,序号:%d",[NSThread currentThread],i);
    }
}



#pragma mark -创建第二个线程
-(void)test2{
    //创建线程,该方法没有返回值
    [NSThread detachNewThreadSelector:@selector(run2:) toTarget:self withObject:@"test2"];
}

-(void)run2:(NSString *)str{
    for (int i=0; i<4; i++) {
        NSLog(@"当前线程:%@,序号:%d,参数:%@",[NSThread currentThread],i,str);
    }
}



#pragma mark -创建第三个线程
-(void)test3{
    //创建线程,该方法没有返回值
    [self performSelectorInBackground:@selector(run3:) withObject:@"test3"];
}

-(void)run3:(NSString *)str{
    for (int i=0; i<4; i++) {
        NSLog(@"当前线程:%@,序号:%d,参数:%@",[NSThread currentThread],i,str);
    }
}



#pragma mark -创建第四个线程:设置线程的属性
-(void)test4{
    NSThread *newThread=[[NSThread alloc] initWithTarget:self selector:@selector(run4:) object:@"test4"];
    newThread.name=@"threadA";//线程的名字
    newThread.threadPriority=0.1;//线程优先级, 是一个浮点数, 0.0~1.0, 默认值是0.5, 数值越大,调度的优先级高, 优先级必须很多次的时候才能体现出来
    [newThread start];
}

-(void)run4:(NSString *)str{
    for (int i=0; i<4; i++) {
        NSLog(@"%@ -----%d----%@",[NSThread currentThread],i ,str);
    }
}
@end

NSThread的常用方法:

   //实例化一个线程对象  start方法启动线程
    NSThread *thread=[[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
    [thread start];
    
    //创建线程后自动启动线程
    [NSThread detachNewThreadSelector:@selector(run) toTarget:self withObject:nil];
    
    //隐式创建并启动线程
    [self performSelectorInBackground:@selector(run) withObject:nil];

    //线程的名字
    - (void)setName:(NSString *)n;
    - (NSString *)name;

    // 获得主线程,判断是否为主线程
    + (NSThread *)mainThread;
    - (BOOL)isMainThread; 
    + (BOOL)isMainThread; 
    
    //获得当前线程
    NSThread *current = [NSThread currentThread];
    
    //线程的调度优先级(调度优先级的取值范围是0.0 ~ 1.0,默认0.5,值越大,优先级越高,自己开发时,建议一般不要修改优先级)
    + (double)threadPriority;
    + (BOOL)setThreadPriority:(double)p;
    - (double)threadPriority;
    - (BOOL)setThreadPriority:(double)p;
  • <3>GCD的用法
/**
 *  串行队列的同步执行
 *  同步执行:不会开启新线程,在原来的线程(主线程)中一个一个的执行
 */
-(void)gcdTest1{
    //1.创建一个串行队列    参数1:队列标签  参数2:队列属性  SERIAL连续的意思
    dispatch_queue_t queue=dispatch_queue_create("itcast", DISPATCH_QUEUE_SERIAL);
    //2.执行任务
    //一般只要是使用同步执行,串行队列对添加的同步任务,会立马执行,所以先打印”线程“信息,然后打印"完成"信息
    for (int i=0; i<4; i++) {
        dispatch_sync(queue, ^{
            NSLog(@"线程:%@,序号:%d",[NSThread currentThread],i);
        });
    }
    NSLog(@"完成 %@",[NSThread currentThread]);
}

打印结果
======================================
线程:<NSThread: 0x60000339a940>{number = 1, name = main},序号:0
线程:<NSThread: 0x60000339a940>{number = 1, name = main},序号:1
线程:<NSThread: 0x60000339a940>{number = 1, name = main},序号:2
线程:<NSThread: 0x60000339a940>{number = 1, name = main},序号:3
完成 <NSThread: 0x600003855400>{number = 1, name = main}
/**
 *  串行队列的异步执行
 *  异步执行:会开启新线程,在新线程中执行,因为是串行,在队列中一个一个的取任务,所以你开启更多个新线程也没有意义,就只开启一个新线程
 */
-(void)gcdTest2{
    //1.串行队列
    dispatch_queue_t queue=dispatch_queue_create("itcast", DISPATCH_QUEUE_SERIAL);
    //2.异步执行
    //因为是异步执行,又是串行一个一个的去执行,所以会先执行主任务里面的"完成"信息,然后再执行异步任务“线程”信息
    for (int i=0; i<4; i++) {
        dispatch_async(queue, ^{
            NSLog(@"线程:%@,序号:%d",[NSThread currentThread],i);
        });
    }
    NSLog(@"完成 %@",[NSThread currentThread]);
}

打印结果
======================================
完成 <NSThread: 0x600001a06fc0>{number = 1, name = main}
线程:<NSThread: 0x6000013c1780>{number = 3, name = (null)},序号:0
线程:<NSThread: 0x6000013c1780>{number = 3, name = (null)},序号:1
线程:<NSThread: 0x6000013c1780>{number = 3, name = (null)},序号:2
线程:<NSThread: 0x6000013c1780>{number = 3, name = (null)},序号:3
/**
 *  并发队列的异步执行
 *  异步执行:一定会开辟新线程的,并发的会开启多个线程
 */
-(void)gcdTest3{
    //1.创建一个并行队列    参数1:队列标签  参数2:队列属性  CONCURRENT并发的意思
    dispatch_queue_t queue=dispatch_queue_create("cz", DISPATCH_QUEUE_CONCURRENT);
    //2.执行
    //因为是异步执行,又是并发执行,所以打印“线程”信息的顺序结果不确定,不过先打印出主线程的“完成”信息
    for (int i=0; i<4; i++) {
        dispatch_async(queue, ^{
            NSLog(@"线程:%@,序号:%d",[NSThread currentThread],i);
        });
    }
    NSLog(@"完成 %@",[NSThread currentThread]);
}

打印结果
======================================
线程信息顺序不确定
/**
 *并发队列的同步执行
 *同步执行:不会开启线程,在原线程中执行任务,虽然是并行,但只有一个线程,还是一条一条的按照顺序执行
 */
-(void)gcdTest4{
    //1.创建一个并行队列
    dispatch_queue_t queue=dispatch_queue_create("zc", DISPATCH_QUEUE_CONCURRENT);
    //2、同步就不会开启新的线程,在原来的线程里面一个一个的执行
    for (int i=0; i<4; i++) {
        dispatch_sync(queue, ^{
            NSLog(@"线程:%@,序号:%d",[NSThread currentThread],i);
        });
    }
    NSLog(@"完成 %@",[NSThread currentThread]);
}

打印结果
======================================
线程:<NSThread: 0x60000338e900>{number = 1, name = main},序号:0
线程:<NSThread: 0x60000338e900>{number = 1, name = main},序号:1
线程:<NSThread: 0x60000338e900>{number = 1, name = main},序号:2
线程:<NSThread: 0x60000338e900>{number = 1, name = main},序号:3
完成 <NSThread: 0x60000338e900>{number = 1, name = main}
/**
 * 主队列的异步执行
 * 主队列:专门负责在主线程上调度任务,不会在子线程上调度任务
 * 主队列的特点:不允许开启新线程,主队列的权限大
 * 异步执行:会开启新线程,但是在主队列中无法开启新线程
 *
 *结果:没有问题,等到test5在主线程上执行结束之后,里面的任务才开始放到主线程上执行,"完成"打印出来,才开始执行定义的异步任务任务
 */
-(void)gcdTest5{
    //1.获得主队列 -> 程序启动 -> 至少有一个主线程 -> 一开始就创建主队列
    dispatch_queue_t queue=dispatch_get_main_queue();
    //2.异步执行任务:把任务放到主队列,但是不需要马上执行
    for (int i=0; i<4; i++) {
        NSLog(@"调度前,序号:%d",i);
        dispatch_async(queue, ^{
            NSLog(@"线程:%@,序号:%d",[NSThread currentThread],i);
        });
        NSLog(@"睡会,序号:%d",i);
        [NSThread sleepForTimeInterval:1.0];
    }
    NSLog(@"完成 %@",[NSThread currentThread]);
}

打印结果
======================================
调度前,序号:0
睡会,序号:0
调度前,序号:1
睡会,序号:1
调度前,序号:2
睡会,序号:2
调度前,序号:3
睡会,序号:3
完成 <NSThread: 0x600002a80000>{number = 1, name = main}
线程:<NSThread: 0x600002a80000>{number = 1, name = main},序号:0
线程:<NSThread: 0x600002a80000>{number = 1, name = main},序号:1
线程:<NSThread: 0x600002a80000>{number = 1, name = main},序号:2
线程:<NSThread: 0x600002a80000>{number = 1, name = main},序号:3
/**
 *  主队列的同步执行
 *  同步执行:是需要马上执行的,不会等待
 *  结果:只有一个主队列,所以主队列上的gcdTest6方法一直占据着,但是又因为是同步的,所以一直在等着下面的任务执行,但是任务有等着gcdTest6执行,所以会造成死锁
 */
-(void)gcdTest6{
    dispatch_queue_t queue=dispatch_get_main_queue();
    for (int i=0; i<10; i++) {
        NSLog(@"调度前,序号:%d",i);
        dispatch_sync(queue, ^{
            NSLog(@"线程:%@,序号:%d",[NSThread currentThread],i);
        });
        NSLog(@"睡会,序号:%d",i);
        [NSThread sleepForTimeInterval:1.0];
    }
    NSLog(@"完成%@",[NSThread currentThread]);
}

打印结果
======================================
卡死啦
#pragma mark - 线程之间的通信

/**
线程之间的通信
*/
dispatch_async(dispatch_get_global_queue(0, 0), ^{// 异步执行
      //耗时操作放在这里
        
      dispatch_async(dispatch_get_main_queue(), ^{//回到主线程
          //一般在主线程处理UI
      });
 });
#pragma mark - gcd的延迟方法

    //方法一:NSObject的延迟方法
    [self performSelector:@selector(run) withObject:nil afterDelay:2.0];
    
    //方法二:GCD的延迟方法
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        
    });
#pragma mark - gcd的调度组

/**
     队列组
     分别异步执行多个任务,要等到这些任务全部都执行完毕后,才回到主线程
     这样的时候一般会用到队列组
     */
    
    //实例化一个调度组
    dispatch_group_t group=dispatch_group_create();
    //创建一个队列
    dispatch_queue_t queue=dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    //把任务添加到队列queue中
    dispatch_group_async(group, queue, ^{
        NSLog(@"下载小说A %@",[NSThread currentThread]);
    });
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"下载小说B %@",[NSThread currentThread]);
    });
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"下载小说C %@",[NSThread currentThread]);
    });
    
    //一:获得调度组里面的所有异步任务完成的通知
    dispatch_group_notify(group, queue, ^{
        //这里是异步的,无法知道他在哪个线程里执行,可能会开辟一个新的线程,也可能在原来的哪个线程里执行
        NSLog(@"下载完成,请观看--%@",[NSThread currentThread]);
    });
    
    //二:指定一个queue,所以可以跨队列通信,这样就可以在主线程里进行更新UI等操作
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        //在主线程,完成下列操作,所以线程的number=1
        NSLog(@"下载完成 -%@",[NSThread currentThread]);
    });
#pragma mark - gcd的一次性执行

  /**GCD实现代码只执行一次
    使用dispatch_once能保证某段代码在程序运行过程中只被执行1次。可以用来设计单例。
     */
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"程序运行过程中我只执行了一次!");
    });
  • <4>NSOperation的用法
    NSOperation是将GCD进行封装起来使用的
#pragma mark - NSInvocationOperation的使用

-(void)opTest1{
    //1、创建操作
    NSOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run1:) object:@"opTest1"];
    //2、执行任务:这样直接在当前线程中执行,没有意义
    [op start];
}

-(void)run1:(id)obj{
    NSLog(@"当前线程:%@,参数:%@",[NSThread currentThread],obj);
}

/**
 打印结果
 ==========================================
 当前线程:<NSThread: 0x600001a0e940>{number = 1, name = main},参数:opTest1
 */



-(void)opTest2{
    //1、创建主队列,mainQueue跟GCD里面的主队列一样
    NSOperationQueue *queue = [NSOperationQueue mainQueue];
    //2、创建操作
    for (int i=0; i<4; i++) {
        NSOperation *op=[[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run2:) object:@"opTest2"];
        [queue addOperation:op];
    }
    NSLog(@"完成%@",[NSThread currentThread]);
}

-(void)run2:(id)obj{
    NSLog(@"当前线程:%@,参数:%@",[NSThread currentThread],obj);
}

/**
 打印结果
 ==========================================
完成<NSThread: 0x600001159400>{number = 1, name = main}
当前线程:<NSThread: 0x600001159400>{number = 1, name = main},参数:opTest2
当前线程:<NSThread: 0x600001159400>{number = 1, name = main},参数:opTest2
当前线程:<NSThread: 0x600001159400>{number = 1, name = main},参数:opTest2
当前线程:<NSThread: 0x600001159400>{number = 1, name = main},参数:opTest2
 */



-(void)opTest3{
    //1、创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    //2、创建多个任务,并把多个操作放到队列中
    for (int i=0; i<4; i++) {
        NSOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run3:) object:@"opTest3"];
        [queue addOperation:op];
    }
    NSLog(@"完成%@",[NSThread currentThread]);
}

-(void)run3:(id)obj{
    NSLog(@"当前线程:%@,参数:%@",[NSThread currentThread],obj);
}

/**
 打印结果
 ==========================================
完成<NSThread: 0x60000287e900>{number = 1, name = main}
当前线程:<NSThread: 0x6000038cd7c0>{number = 5, name = (null)},参数:opTest3
当前线程:<NSThread: 0x6000038cd780>{number = 3, name = (null)},参数:opTest3
当前线程:<NSThread: 0x6000038c4a80>{number = 4, name = (null)},参数:opTest3
当前线程:<NSThread: 0x6000038cd840>{number = 6, name = (null)},参数:opTest3
 */
#pragma mark - NSBlockOperation的使用

-(void)opTest4{
    //1、创建队列
    NSOperationQueue *queue=[[NSOperationQueue alloc] init];
    //2、创建多个任务,并多个操作放到队列中
    for (int i=0; i<4; i++) {
        NSOperation *op=[NSBlockOperation blockOperationWithBlock:^{
            NSLog(@"当前线程:%@,序号:%d",[NSThread currentThread],i);
        }];
        [queue addOperation:op];
    }
    NSLog(@"完成%@",[NSThread currentThread]);
}

/**
 打印结果
=======================================================
完成<NSThread: 0x600001eb5400>{number = 1, name = main}
当前线程:<NSThread: 0x6000031bd040>{number = 4, name = (null)},序号:2
当前线程:<NSThread: 0x6000031bcf80>{number = 6, name = (null)},序号:1
当前线程:<NSThread: 0x6000031a48c0>{number = 3, name = (null)},序号:0
当前线程:<NSThread: 0x6000031a6340>{number = 5, name = (null)},序号:3
*/



-(void)opTest5{
    //1、创建主队列,mainQueue跟GCD里面的主队列一样
    NSOperationQueue *queue=[NSOperationQueue mainQueue];
    //2、生成多个操作,并添加到队列中
    for (int i=0; i<4; i++) {
        NSBlockOperation *op=[NSBlockOperation blockOperationWithBlock:^{
            NSLog(@"当前线程:%@,序号:%d",[NSThread currentThread],i);
        }];
        [queue addOperation:op];
    }
    NSLog(@"完成%@",[NSThread currentThread]);
}

/**
 打印结果
先打印出“完成”信息,然后再打印线程信息
结果:在主队列上执行代码,只有一条线程,所以先执行完毕opTest4之后,再在主线程上执行新建的4个任务,一个一个执行
=======================================================
完成<NSThread: 0x600001f95400>{number = 1, name = main}
当前线程:<NSThread: 0x600001f95400>{number = 1, name = main},序号:0
当前线程:<NSThread: 0x600001f95400>{number = 1, name = main},序号:1
当前线程:<NSThread: 0x600001f95400>{number = 1, name = main},序号:2
当前线程:<NSThread: 0x600001f95400>{number = 1, name = main},序号:3
*/
#pragma mark -NSBlockOperation的更简单的使用

-(void)opTest6{
    //1.创建队列
    NSOperationQueue *queue=[[NSOperationQueue alloc] init];
    
    NSBlockOperation *op1=[NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"当前线程:%@----op1",[NSThread currentThread]);
    }];
    [queue addOperation:op1];
    
    //NSBlockOperation里面还有一个方法 addExecutionBlock 可以在操作里面再添加操作,其前提是:op1是NSBlockOperation类的对象
    [op1 addExecutionBlock:^{
        NSLog(@"当前线程:%@----op1可以再添加操作",[NSThread currentThread]);
    }];
}

/**
 打印结果
 ==================================================================
 当前线程:<NSThread: 0x60000266dd00>{number = 4, name = (null)}----op1可以再添加操作
 当前线程:<NSThread: 0x60000266dc40>{number = 3, name = (null)}----op1
 */


-(void)opTest7{
    //1.创建队列
    NSOperationQueue *queue=[[NSOperationQueue alloc] init];
    for (int i=0; i<4; i++) {
        //2、向队列添加任务
        [queue addOperationWithBlock:^{
            NSLog(@"当前线程:%@,序号:%d",[NSThread currentThread],i);
        }];
    }
}

/**
 打印结果
==================================================================
当前线程:<NSThread: 0x600001a42680>{number = 5, name = (null)},序号:3
当前线程:<NSThread: 0x600001a46b00>{number = 4, name = (null)},序号:1
当前线程:<NSThread: 0x600001a48600>{number = 6, name = (null)},序号:2
当前线程:<NSThread: 0x600001a42640>{number = 3, name = (null)},序号:0
*/
#pragma mark - NSBlockOperation线程间的通信
//如果要做线程间的通信,可以使用[NSOperationQueue mainQueue]拿到主队列,往主队列中添加操作(更新UI)

-(void)opTest8{
    NSOperationQueue *queue=[[NSOperationQueue alloc] init];
    [queue addOperationWithBlock:^{
        NSLog(@"耗时操作...%@",[NSThread currentThread]);
        
        //在主线程执行下列操作,比如更新UI
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            NSLog(@"更新UI  ...%@",[NSThread currentThread]);
        }];
    }];
}
#pragma mark -NSOperation的最大并发数

-(void)opTest9{
    //最大并发数并不是指线程数,而是指同一时间内只能有几个任务能同时进行
    NSOperationQueue *queue=[[NSOperationQueue alloc] init];
    queue.maxConcurrentOperationCount=2;
    
    for (int i=0; i<100; i++) {
        NSOperation *op=[NSBlockOperation blockOperationWithBlock:^{
            NSLog(@"%@--%d",[NSThread currentThread],i);
            [NSThread sleepForTimeInterval:1.0];
        }];
        [queue addOperation:op];
    }
}
#pragma mark -NSOperation的挂起、取消全部操作

NSOperationQueue *queue=[[NSOperationQueue alloc] init];
//queue.operationCount : 操作队列里面的操作数量
//queue.suspended : 布尔类型,YES代表暂停,NO表示恢复队列,默认状态是0,也就是NO


//对应暂停、继续按钮
-(void)opTest10{
    //判断当前操作队列里面的操作数量。假如没有操作,这条队列里面就不要有暂停和继续的功能,假如有操作,我们就需要有暂停和继续的功能
    if(queue.operationCount==0){
        NSLog(@"没有操作");
        return;
    }
    
    //暂停和继续
    //suspended是布尔类型的,YES代表暂停,NO表示恢复队列,默认状态是0,也就是NO
    queue.suspended=!queue.suspended;
    if (queue.suspended) {
        NSLog(@"暂停");
    }else{
        NSLog(@"继续");
    }
}


//对应取消操作
-(void)opTest11{
    //取消队列的所有操作,取消操作并不会影响队列的挂起状态
    //这里需要知道的就是,取消的是队列里面的操作,但是线程中正在执行的是无法取消的
    [queue cancelAllOperations];
    NSLog(@"取消队列里面的所有操作");
}
#pragma mark -NSOperation的依赖关系

//1.下载一个小说的安装包,   2.解压缩,删除压缩包   3.更新UI
NSOperationQueue *queue=[[NSOperationQueue alloc] init];

-(void)dependecy{
    NSBlockOperation *op1=[NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"1.下载一个小说的压缩包,%@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *op2=[NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"2.解压缩,删除压缩包 %@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *op3=[NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"3.更新UI %@",[NSThread currentThread]);
    }];
    
    //制定依赖关系,op2要等op1执行完毕,op3要等待op2执行完毕,但是这里的op3是在主线程中执行的,所以要等到Come here打印出来,才会打印op3的操作
    //依赖关系是可以跨队列的,(像按照顺序的在子线程执行op1,op2,然后在主线程上执行op3,这就是跨队列的)
    [op2 addDependency:op1];
    [op3 addDependency:op2];
    
  //WaitUntilFinished类似于GCD的调度组的通知,NO就不会等待队列里面的任务执行,直接打印Come here ,
  //要是是YES的话就会等待3个任务执行完毕再打印“Come here”,但是因为此处的op3是在主线程中执行,所以会在打印出“Come here”后才会执行op3
  //在queue中执行op1、op2  
  [queue addOperations:@[op1,op2] waitUntilFinished:YES];
    
    //在主线程执行op3,更新UI
    [[NSOperationQueue mainQueue] addOperation:op3];
    NSLog(@"Come here");
}
4、总结
  • <1>你理解的多线程?
    多线程就是说在一个进程(iOS中可以理解为应用程序)中,除了主线程之外,还可以开辟些其他进程,用于处理一些耗时操作。

  • <2>iOS的多线程方案有哪几种?
    四种:pthread、NSThread、GCD、NSOperation。
    其他三种都是在pthread的基础上实现的,一般使用GCD就足够了,当有很多高级用法的时候,才使用NSOperation。
    具体区别见上面详解。

  • <3> NSOperation 和 GCD 的区别
    (1)、GCD将任务通过block的方式添加到队列(队列分为:串行、并发(全局)),指定执行任务的方法(同步(阻塞)、异步)
    GCD中的线程通信是拿到主队列dispatch_main_queue,在主队列中更新UI
    (2)、NSOPeration将任务添加到队列(并发(全局)、异步)
    [NSOpeartionQueue mainQueue]主队列,任务添加到主队列中,就会在主线程执行

GCD中可以做到一次性执行dispatch_once_t、延迟执行、调度组,NSOPeration不好实现
NSOPeration提供了一些GCD不好实现的功能:最大并发数、暂停和继续、取消全部任务、依赖关系

推荐阅读更多精彩内容