iOSiOS随笔iOS Developer

iOS之多线程：线程的生命周期，NSThread、GCD、NSO

2019-06-11  本文已影响9人  陌路卖酱油

前言：

我负责努力，其余交给运气。

正文：

闲暇之余，把线程的问题整理一下，感觉可能会有点长，所以先自分一下章节，我将会按照以下几个小节来展开描述：

1.多线程的基本概念

2.线程的状态与生命周期

3.多线程的对比：pthread、NSThread、GCD、NSOperation

4.NSThread的使用

5.GCD的理解与使用

6.NSOperation的理解与使用

一、多线程的基本概念
二、线程的状态与生命周期

如下图所示，线程的生命周期是：新建、就绪、运行、阻塞、死亡：

线程状态图
三、多线程的对比：pthread、NSThread、GCD、NSOperation
线程对比图

相比于pthread和NSThread，GCD和NSOperation更常用一些，所以着重说一下GCD和NSOperation：

GCD 和 NSOperation的区别主要表现在以下几方面:

  1. GCD是一套 C 语言API,执行和操作简单高效，因此NSOperation底层也通过GCD实现，这是他们之间最本质的区别.因此如果希望自定义任务，建议使用NSOperation；

  2. 依赖关系，NSOperation可以设置操作之间的依赖(可以跨队列设置)，GCD无法设置依赖关系，不过可以通过同步来实现这种效果；

  3. KVO(键值对观察)，NSOperation容易判断操作当前的状态(是否执行，是否取消等)，对此GCD无法通过KVO进行判断；

  4. 优先级，NSOperation可以设置自身的优先级，但是优先级高的不一定先执行，GCD只能设置队列的优先级，如果要区分block任务的优先级,需要很复杂的代码才能实现；

  5. 继承，NSOperation是一个抽象类.实际开发中常用的是它的两个子类:NSInvocationOperation和NSBlockOperation，同样我们可以自定义NSOperation，GCD执行任务可以自由组装，没有继承那么高的代码复用度；

  6. 效率，直接使用GCD效率确实会更高效，NSOperation会多一点开销，但是通过NSOperation可以获得依赖，优先级，继承，键值对观察这些优势，相对于多的那么一点开销确实很划算，鱼和熊掌不可得兼，取舍在于开发者自己；

  7. 可以随时取消准备执行的任务(已经在执行的不能取消),GCD没法停止已经加入queue 的 block(虽然也能实现,但是需要很复杂的代码)

基于GCD简单高效,更强的执行能力，操作不太复杂的时候,优先选用GCD;而比较复杂的任务可以自己通过NSOperation实现.

四、NSThread的使用
4.1 NSThread的创建

NSThread有三种创建方式：

直接上代码:

- (void)showNSThread{
    /** 方法一，需要start */
    NSThread* thread1 = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething1:) object:@"1"];
    [thread1 start];
     /** 方法二，创建好之后自动启动 */
    [NSThread detachNewThreadSelector:@selector(doSomething2:) toTarget:self withObject:@"2"];
    /** 方法三，隐式创建，直接启动 */
    [self performSelectorInBackground:@selector(doSomething3:) withObject:@"3"];
}
- (void)doSomething1:(NSObject*)obj{
    NSLog(@"doSometing1 ---- obj = %@",obj);
}
- (void)doSomething2:(NSObject*)obj{
    NSLog(@"doSometing2 ---- obj = %@",obj);
}
- (void)doSomething3:(NSObject*)obj{
    NSLog(@"doSometing3 ---- obj = %@",obj);
}
4.2 NSThread的一些属性、实例方法、类方法**
/**
每个线程都维护了一个键-值的字典,它可以在线程里面的任何地方被访问。
可以使用该字典来保存一些信息,这些信息在整个线程的执行过程中都保持不变。
比如,你可以使用它来存储在你的整个线程过程中 Run loop 里面多次迭代的状态信息。
NSThread实例可以使用一下方法:
NSMutableDictionary *dict = [thread threadDictionary]; 
*/
@property (readonly, retain) NSMutableDictionary *threadDictionary;

@property double threadPriority ; //优先级

/**NSQualityOfService说明:
NSQualityOfServiceUserInteractive：最高优先级,主要用于提供交互UI的操作,比如处理点击事件,绘制图像到屏幕上
NSQualityOfServiceUserInitiated：次高优先级，主要用于执行需要立即返回的任务
NSQualityOfServiceDefault：默认优先级，当没有设置优先级的时候，线程默认优先级
NSQualityOfServiceUtility：普通优先级，主要用于不需要立即返回的任务
NSQualityOfServiceBackground：后台优先级，用于完全不紧急的任务
*/
@property NSQualityOfService qualityOfService; //线程优先级

@property (nullable, copy) NSString *name;//线程名称

@property NSUInteger stackSize ;//线程使用栈区大小，默认是512K

@property (readonly, getter=isExecuting) BOOL executing;//线程是否正在执行

@property (readonly, getter=isFinished) BOOL finished;//线程是否执行结束

@property (readonly, getter=isCancelled) BOOL cancelled;//线程是否可被取消


-(void)start; //启动线程（init创建的线程，需start启动，不自行运行）

-(BOOL)isMainThread; //是否为主线程

-(void)setName:(NSString *)n; //设置线程名称

-(void)cancel ; //取消线程

-(void)main ; //线程的入口函数

-(void)isExecuting; //判断线程是否正在执行

-(void)isFinished; //判断线程是否已经结束

-(void)isCancelled; //判断线程是否撤销

+(void)currentThread; //获取当前线程

+(BOOL)isMultiThreaded; //当前代码运行所在线程是否是子线程

+(void)sleepUntilDate:(NSDate *)date; //当前代码所在线程睡到指定时间

+(void)sleepForTimeInterval:(NSTimeInterval)ti; //当前线程睡多长时间

+(void)exit; //退出当前线程

+(double)threadPriority; //设置当前线程优先级
/**给当前线程设定优先级，调度优先级的取值范围是0.0 ~ 1.0，
默认0.5，值越大，优先级越高。*/
+(BOOL)setThreadPriority:(double)p; 
/**
线程的调用都会有函数的调用，函数的调用就会有栈返回地址的记录，
在这里返回的是函 数调用返回的虚拟地址，
说白了就是在该线程中函数调用的虚拟地址的数组
*/
+(NSArray *)callStackReturnAddresses;

+(NSArray *)callStackSymbols; //同上面的方法一样，只不过返回的是该线程调用函数的名字数字

注：callStackReturnAddress和callStackSymbols这两个函数可以同NSLog联合使用来跟踪线程的函数调用情况，是编程调试的重要手段。

五、GCD的理解与使用

5.1 GCD的基本概念

5.2 队列的创建方式
使用dispatch_queue_create来创建队列对象，传入两个参数，第一个参数表示队列的唯一标识符，可为空。第二个参数用来表示串行队列（DISPATCH_QUEUE_SERIAL或零）或并发队列（DISPATCH_QUEUE_CONCURRENT）。

//串行队列
dispatch_queue_t queue1 = dispatch_queue_create("queue1",DISPATCH_QUEUE_SERIAL);

//并行队列
dispatch_queue_t queue2 = dispatch_queue_create("queue2",DISPATCH_QUEUE_CONCURRENT);

GCD的队列还有另外两种：

dispatch_async(dispatch_get_global_queue(0, 0), ^{
      // 耗时操作放在这里
      dispatch_async(dispatch_get_main_queue(), ^{
     // 回到主线程进行UI操作
      });
});

//全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//全局并发队列的优先级
#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高优先级
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默认（中）优先级
#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低优先级
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台优先级

//iOS8开始使用服务质量，现在获取全局并发队列时，可以直接传0
dispatch_get_global_queue(0, 0);

5.3 同步、异步&任务

    // 同步执行任务
    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        // 任务放在这个block里
        NSLog(@"我是同步执行的任务");
    });
    // 异步执行任务
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 任务放在这个block里
        NSLog(@"我是异步执行的任务");
    });

5.4 GCD的使用
由于有多种队列（串行、并发、主队列）和两种执行方式（同步、异步），所以他们之间有多种组合方式：串行同步、串行异步、并发同步、并发异步、主队列同步、主队列异步。

/** 串行同步 */
- (void)serialSynchronization{
    // 串行队列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    // 同步执行
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行同步1,%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行同步2,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数1");
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行同步3,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数2");
}

执行结果为顺序执行，且没有开辟新线程，都在主线程，阻塞了主线程，如图：

串行同步执行结果 
 /** 串行异步 */
- (void)serialAsynchronous {
    // 串行队列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    // 异步执行
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行异步1,%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行异步2,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数1");
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"串行异步3,%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数2");
}

执行结果如下，因为是串行队列，所以异步线程按照顺序执行；但是异步开辟了新的子线程，所以没有阻塞主线程：

串行异步执行结果 
/** 并发同步 */ 
- (void)concurrentSynchronization {
    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    // 同步执行
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"并发同步1，%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"并发同步2，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数1");
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"并发同步3，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数2");
}

执行结果如下，虽然我们选择的并发队列，但是因为是同步线程，所以任务依然是顺序执行，没有开辟新线程，依然在主线程上执行，且阻塞了主线程：

并发同步执行结果 
/** 并发异步 */
- (void)concurrentAsynchronization {
    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    // 异步执行
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"并发异步1，%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"并发异步2，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数1");
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"并发异步3，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数2");
}

执行结果如下，执行顺序无序（并发）、开辟了多条子线程、没有阻塞主线程：

并发异步执行结果 
/** 主队列同步 */
- (void)syncMain {
    // 主队列
    NSLog(@"主线程执行函数1");
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主队列同步1，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数2");
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主队列同步2，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数3");
    dispatch_sync(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主队列同步3，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数4");
}

执行结果如下，xcode8之后，不会阻塞，会崩溃。不过话说回来，主队列同步造成死锁，我们都知道是因为相互等待，可是阻塞、等待的是谁呢？这里要说的是：阻塞的是队列, 不是线程,我们可能会疑惑，为什么其他串行同步不会死锁：输出block确实也在主线程执行, 如果sync阻塞的是主线程, 那按理这样确实会死锁, 但实际上sync阻塞的是主队列, 而不是主线程。其他串行同步运行结果是, dispatch_sync运行在主队列, 而其block运行在queue队列, 虽然两个队列都是由主线程执行, 由于dispatch_sync阻塞的只是主队列, block在queue队列由主线程执行完并返回, 从而dispatch_sync返回, 之后主队列结束阻塞继续执行下面任务. 此处queue队列是运行在主线程的另一串行队列（是不是很懵~~ 哈哈~~ 看下面模拟阻塞代码会清楚一些）。

我们自己模拟出主队列阻塞可能更容易理解：

dispatch_queue_t queue = dispatch_queue_create("queue1", DISPATCH_QUEUE_SERIAL);//可以把queue理解为主队列
dispatch_sync(queue, ^{//可以把这理解为主线程
    dispatch_sync(queue, ^{//主线程中主队列同步   
    });
});

这样就把串行队列queue阻塞了.

主队列同步执行结果 
/** 主队列异步 */
- (void)asyncMain {
    // 主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主队列异步1，%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主队列异步2，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数1");
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"主队列异步3，%@",[NSThreadcurrentThread]);
        }
    });
    NSLog(@"主线程执行函数2");
}

执行结果如下，在主线程中任务按顺序执行，但并没有阻塞主线程：

主队列异步

我们通过上面六种组合，可以看到，同步不论串行还是并发，都没有开辟新线程，运行在主线程上，且都是顺序执行，所以并没有并发效果。异步不论串行还是并发，都开启了新线程（子线程），但是可见的是，多条异步串行，只开辟了一个子线程，多条异步并发，开启了多条子线程。主队列异步，并没有开启子线程，且为有序串行执行，但并没有阻塞主线程。

- (IBAction)communicationBetweenThread:(id)sender {
    // 异步
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 耗时操作放在这里，例如下载图片。（运用线程休眠两秒来模拟耗时操作）
        [NSThread sleepForTimeInterval:2];
        NSString *picURLStr = @"https://123.jpg";
        NSURL *picURL = [NSURL URLWithString:picURLStr];
        NSData *picData = [NSData dataWithContentsOfURL:picURL];
        UIImage *image = [UIImage imageWithData:picData];
        // 回到主线程处理UI
        dispatch_async(dispatch_get_main_queue(), ^{
            // 在主线程上添加图片
            self.imageView.image = image;
        });
    });
}

dispatch_barrier_sync 将自己的任务插入到队列的时候，需要等待自己的任务结束之后才会继续插入被写在它后面的任务，然后执行它们。

dispatch_barrier_async 将自己的任务插入到队列之后，不会等待自己的任务结束，它会继续把后面的任务插入到队列，然后等待自己的任务结束后才执行后面任务。

实际上类似于同步异步，下面以dispatch_barrier_async为例：

- (void)barrierGCD {
    // 并发队列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    // 异步执行
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"栅栏：并发异步1，%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"栅栏：并发异步2，%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_barrier_async(queue, ^{
        NSLog(@"------------barrier------------%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"栅栏：并发异步3，%@",[NSThreadcurrentThread]);
        }
    });
    dispatch_async(queue, ^{
        for(inti =0; i <3; i++) {
            NSLog(@"栅栏：并发异步4，%@",[NSThreadcurrentThread]);
        }
    });
}

执行结果如下，开启了多条线程，所有任务都是并发异步进行。但是第一组完成之后，才会进行第二组的操作

栅栏执行结果

需要注意的是：
dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block)，栅栏函数中传入的参数队列必须是由 dispatch_queue_create 方法创建的队列，否则，与dispatch_async无异，起不到“栅栏”的作用了，对于dispatch_barrier_sync也是同理。

（1）dispatch_group_t相关属性介绍：

1.dispatch_group_async(group, queue, block);
将block任务添加到queue队列，并被group组管理

2.dispatch_group_enter(group);
声明dispatch_group_enter(group)下面的任务由group组管理，group组的任务数+1

3.dispatch_group_leave(group);
相应的任务执行完成，group组的任务数-1

4.dispatch_group_create();
创建一个group组

5.dispatch_group_wait(group1, DISPATCH_TIME_FOREVER);
当前线程暂停，等待dispatch_group_wait(group1, DISPATCH_TIME_FOREVER)上面的任务执行完成后，线程才继续执行。

6.dispatch_group_notify(group1, queue1,block);
监听group组中任务的完成状态，当所有的任务都执行完成后，触发block块，执行总结性处理。

（2）常见用法的区别
在使用group组处理任务时，常见的有两种组合。

其一：

dispatch_group_async(group, queue, block);

dispatch_group_notify(group1, queue1, block);

在这种组合下，根据任务是同步、异步又分为两种，这两种组合的执行代码与运行结果如下：

同步任务时：

- (void)groupSync{
    dispatch_queue_t queue1 = dispatch_queue_create("queue1", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t group1 = dispatch_group_create();
    dispatch_group_async(group1, queue1, ^{
        dispatch_sync(queue1, ^{
            for(NSInteger i =0; i<3; i++) {
                NSLog(@"同步任务1-:%ld",(long)i);
            }
        });
    });
    dispatch_group_async(group1, queue1, ^{
        dispatch_sync(queue1, ^{
            for(NSInteger i =0; i<3; i++) {
                sleep(1);
                NSLog(@"同步任务2-:%ld",(long)i);
            }
        });
    });
    //等待上面的任务全部完成后，会收到通知执行block中的代码 （不会阻塞线程）
    dispatch_group_notify(group1, queue1, ^{
        NSLog(@"全部任务执行完成");
    });
}
group-同步

异步任务时：

- (void)groupAsync{
    dispatch_queue_t queue1 = dispatch_queue_create("queue1", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t group1 = dispatch_group_create();
    dispatch_group_async(group1, queue1, ^{
        dispatch_async(queue1, ^{
            for(NSInteger i =0; i<3; i++) {
                sleep(1);
                NSLog(@"异步任务1,%ld",(long)i);
            }
        });
    });
    dispatch_group_async(group1, queue1, ^{
        dispatch_async(queue1, ^{
            for(NSInteger i =0; i<3; i++) {
                sleep(1);
                NSLog(@"异步任务2,%ld",(long)i);
            }
        });
    });
    //等待上面的任务全部完成后，会收到通知执行block中的代码 （不会阻塞线程）
    dispatch_group_notify(group1, queue1, ^{
        NSLog(@"全部任务执行完成");
    });
}
group-异步

结论：dispatch_group_async(group, queue, block) 和 dispatch_group_notify(group1, queue1, block) 组合在执行同步任务时正常，在执行异步任务时不正常。

其二：

dispatch_group_enter(group);

dispatch_group_leave(group);

dispatch_group_notify(group1, queue1,block);

同样的在这种组合下，根据任务是同步、异步也分为两种，这两种组合的执行代码与运行结果如下：

同步任务时：

- (void)groupSyncEnter {
    dispatch_queue_t queue2 = dispatch_queue_create("queue2", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t group2 = dispatch_group_create();
    dispatch_group_enter(group2);
    dispatch_sync(queue2, ^{
        for(NSInteger i =0; i<3; i++) {
            NSLog(@"同步任务1,%ld",(long)i);
        }
        dispatch_group_leave(group2);
    });
    dispatch_group_enter(group2);
    dispatch_sync(queue2, ^{
        for(NSInteger i =0; i<3; i++) {
            NSLog(@"同步任务2,%ld",(long)i);
        }
        dispatch_group_leave(group2);
    });
    //等待上面的任务全部完成后，会收到通知执行block中的代码 （不会阻塞线程）
    dispatch_group_notify(group2, queue2, ^{
        NSLog(@"全部任务执行完成");
    });
}
group-同步

异步任务时：

- (void)groupAsyncEnter{
    dispatch_queue_t queue2 = dispatch_queue_create("queue2", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t group2 = dispatch_group_create();
    dispatch_group_enter(group2);
    dispatch_async(queue2, ^{
        for(NSInteger i =0; i<3; i++) {
            NSLog(@"异步任务1,%ld",(long)i);
        }
        dispatch_group_leave(group2);
    });
    dispatch_group_enter(group2);
    dispatch_async(queue2, ^{
        for(NSInteger i =0; i<3; i++) {
            NSLog(@"异步任务2,%ld",(long)i);
        }
        dispatch_group_leave(group2);
    });
    //等待上面的任务全部完成后，会收到通知执行block中的代码 （不会阻塞线程）
    dispatch_group_notify(group2, queue2, ^{
        NSLog(@"全部任务执行完成");
    });
}
group-异步

结论：dispatch_group_enter(group)、dispatch_group_leave(group) 和dispatch_group_notify(group, queue,block) 组合在执行同步任务时正常，在执行异步任务时正常。

/**在必须将不可并行执行的处理追加到多个Serial Dispatch Queue中时，
如果使用dispatch_set_target_queue函数将目标指定为某一个Serial Dispatch Queue，
即可防止处理并行执行。*/
dispatch_set_target_queue 

 /**想在指定时间后执行处理的情况，可使用dispatch_after函数来实现。
需要注意的是，dispatch_after函数并不是在指定时间后执行处理，
而只是在指定时间追加处理到Dispatch Queue。*/
dispatch_after

dispatch_apply//第一个参数为重复次数，第二个参数为追加对象的Dispatch，第三个参数为追加的处理
dispatch_apply(10, queue, ^(size_t index) {
    NSLog(@"%zu",index);
});

dispatch_suspend(queue)//函数挂起指定的Dispatch Queue

dispatch_resume(queue)//函数恢复指定的Dispatch Queue
 
dispatch_once//函数是保证在应用程序执行中只执行一次指定处理的API

- (void)stopSync{
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    dispatch_block_t block1 = dispatch_block_create(0, ^{
        NSLog(@"block1 begin");
        [NSThread sleepForTimeInterval:3];
        NSLog(@"block1 end");
    });

    dispatch_block_t block2 = dispatch_block_create(0, ^{
        NSLog(@"block2 ");
    });
    dispatch_async(queue, block1);
    dispatch_async(queue, block2);
    //取消执行block2
    dispatch_block_cancel(block2);
}

运行结果如下：

image

但是，如果执行中的线程，我们该怎么让其退出呢？方法如下：

- (void)stopAsync {
    __block BOOL isFinish =NO;
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        for(long i=0; i<10000; i++) {
            NSLog(@"正在执行第 %ld 次",i);
            sleep(1);
            if(isFinish ==YES) {
                NSLog(@"已经终止了");
                return;
            }
        };
    });
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW,(int64_t)(10 * NSEC_PER_SEC)),dispatch_get_main_queue(), ^{
        NSLog(@"我要停止啦");
        isFinish =YES;
    });
}

执行结果：

image

方法很简单，线程外设置__block变量，配合线程中return结束。

六、NSOperation的理解与使用

6.1 NSOperation, NSOperationQueue 简介

NSOperation需要配合NSOperationQueue来实现多线程；NSOperation，NSOperationQueue 是苹果提供给我们的一套多线程解决方案，是基于 GCD 更高一层的封装，完全面向对象。但是比 GCD 更简单易用，代码可读性更高。

既然是基于 GCD 的更高一层的封装。那么，GCD 的一些概念同样适用于 NSOperation，NSOperationQueue。在 NSOperation，NSOperationQueue 中也有类似于任务（操作）和队列（操作队列）的概念。

NSOperation实现多线程的步骤如下：

  1. 创建操作：先将要执行的操作封装到一个 NSOperation 对象中
  2. 创建队列：创建 NSOperationQueue 对象。
  3. 将操作加入到队列中：将 NSOpeartion 对象添加到 NSOperationQueue 对象中。

需要注意的是，NSOperation是个抽象类，实际运用时中需要使用它的子类，有三种方式：

  1. 使用子类NSInvocationOperation
  2. 使用子类NSBlockOperation
  3. 定义继承自NSOperation的子类，通过实现内部相应的方法来封装任务。
6.2 NSOperation的三种创建方式
6.2.1 使用NSInvocationOperation创建
//NSInvocationOperation使用
- (void)useNSInvocationOperation{
    //创建NSInvocationOperation并关联方法
    NSInvocationOperation* opratin = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationAction) object:nil];
    //执行操作
    [opratin start];
}
- (void)invocationOperationAction{
    NSLog(@"NSInvocationOperation任务，没有加入队列==%@", [NSThread currentThread]);
}

执行结果如下，得到结论：程序在主线程执行，没有开启新线程。这是因为 NSOperation 多线程的使用需要配合队列 NSOperationQueue ，在不使用 NSOperationQueue ，单独使用 NSOperation 的情况下，系统同步执行操作。

执行结果
6.2.2 使用NSBlockOperation创建
//NSBlockOperation使用
- (void)useNSBlockOperation{
    //创建NSBlockOperation并把任务放到block中
    NSBlockOperation* operation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"NSInvocationOperation任务，没有加入队列==%@", [NSThread currentThread]);
    }];
    //执行操作
    [operation start];
}

执行结果如下，结论上同，不在阐述。


执行结果

但是NSBlockOperation有一个方法addExecutionBlock:，通过这个方法可以让NSBlockOperation实现多线程。代码如下：

//NSBlockOperation使用
- (void)useNSBlockOperation{
    //创建NSBlockOperation并把任务放到block中
    NSBlockOperation* operation = [NSBlockOperation blockOperationWithBlock:^{
        for(int i = 0; i < 3; i++){
            NSLog(@"NSInvocationOperation任务==%@", [NSThread currentThread]);
        }
//        NSLog(@"NSInvocationOperation任务，没有加入队列==%@", [NSThread currentThread]);
    }];
    [operation addExecutionBlock:^{
        for(int i = 0; i < 3; i++){
            NSLog(@"addExecutionBlock方法添加任务1==%@", [NSThread currentThread]);
        }
    }];
    [operation addExecutionBlock:^{
        for(int i = 0; i < 3; i++){
            NSLog(@"addExecutionBlock方法添加任务2==%@", [NSThread currentThread]);
        }
    }];
    [operation addExecutionBlock:^{
        for(int i = 0; i < 3; i++){
            NSLog(@"addExecutionBlock方法添加任务3==%@", [NSThread currentThread]);
        }
    }];
    //执行操作
    [operation start];
}

执行结果如下，(第二个执行结果是添加了十个操作，执行了两次出现的结果...)


执行结果1 执行结果2
得到结论：
6.2.3 使用继承自NSOperation的子类创建

首先我们定义一个继承自NSOperation的类，然后重写它的main方法，之后就可以使用这个子类来进行相关的操作了。

/*******************"OurNSOperation.h"*************************/
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
@interface OurNSOperation : NSOperation
@end
NS_ASSUME_NONNULL_END

/*******************"OurNSOperation.m"*************************/
#import "OurNSOperation.h"
@implementation OurNSOperation
- (void)main{
    for(int i = 0; i < 3; i++){
        NSLog(@"NSOperation的子类OurNSOperation==%@",[NSThread currentThread]);
    }
}
@end
/*******"回到主控制器导入头文件并使用OurNSOperation"********/
- (void)useOurNSOperation{
    //创建OurNSOperation对象
    OurNSOperation* operation = [[OurNSOperation alloc] init];
    //开始执行
    [operation start];
}

运行结果如下，依然是在主线程执行。所以，NSOperation是需要配合队列NSOperationQueue来实现多线程的。


执行结果
6.3 队列NSOperationQueue

NSOperationQueue只有两种队列：主队列、自定义队列。自定义队列包含了串行和并发。

6.4 NSOperation + NSOperationQueue

NSOperation 需要配合 NSOperationQueue 来实现多线程,所以把任务加入队列，这才是NSOperation的常规使用方式。

6.4.1 addOperation添加任务到队列

先创建好任务，然后运用addOperation:<#(nonnull NSOperation *)#>方法来吧任务添加到队列中，示例代码如下：

- (void)useAddOperation {
    NSOperationQueue* queue = [[NSOperationQueue alloc] init];
    NSInvocationOperation* operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationActions) object:nil];
    NSBlockOperation* blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        for(int i = 0; i < 3; i++){
            NSLog(@"NSBlockOperation任务 == %@ 第%d次执行",[NSThread currentThread],i);
        }
    }];
    
    [queue addOperation:operation];
    [queue addOperation:blockOperation];
}

- (void)invocationOperationActions {
    for (int i = 0; i < 3; i++){
        NSLog(@"NSInvocationOperation任务 == %@ 第%d次执行",[NSThread currentThread],i);
    }
}

运行结果如下，可以看出，任务都是并发在子线程执行的，开启了新线程。


执行结果
6.4.2 addOperationWithBlock添加任务到队列

这是一个更方便的把任务添加到队列的方法，直接把任务写在block中，添加到任务中。

- (void)useAddOperationWithBlock{
    NSOperationQueue* queue = [[NSOperationQueue alloc] init];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++){
            NSLog(@"任务1 == %@ 第%d次执行",[NSThread currentThread],i);
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++){
            NSLog(@"任务2 == %@ 第%d次执行",[NSThread currentThread],i);
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++){
            NSLog(@"任务3 == %@ 第%d次执行",[NSThread currentThread],i);
        }
    }];
}

执行结果如下，使用 addOperationWithBlock:将操作加入到操作队列后能够开启新线程，进行并发执行。


执行结果
6.4.3 maxConcurrentOperationCount控制串行执行、并发执行

maxConcurrentOperationCount,叫做最大并发操作数，用来控制一个特定队列中可以有多少个操作同时参与并发执行。

注意：这里maxConcurrentOperationCount控制的不是并发线程的数量，而是一个队列中同时能并发执行的最大操作数。而且一个操作也并非只能在一个线程中运行。(6.3中做过一些介绍，不再阐述)

- (void)useMaxConcurrentOperationCount{
    NSOperationQueue* queue = [[NSOperationQueue alloc] init];
    
    //设置并发数
    queue.maxConcurrentOperationCount = 1;//串行队列
//    queue.maxConcurrentOperationCount = 4;//并行队列
//    queue.maxConcurrentOperationCount = 100;//并行队列
    
    // 使用 addOperationWithBlock添加操作到队列中
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务1 == %@ 第%d次执行",[NSThread currentThread],i); // 打印当前线程
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务2 == %@ 第%d次执行",[NSThread currentThread],i); // 打印当前线程
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务3 == %@ 第%d次执行",[NSThread currentThread],i); // 打印当前线程
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务4 == %@ 第%d次执行",[NSThread currentThread],i); // 打印当前线程
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务5 == %@ 第%d次执行",[NSThread currentThread],i); // 打印当前线程
        }
    }];
    
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务6 == %@ 第%d次执行",[NSThread currentThread],i); // 打印当前线程
        }
    }];
}
6.5 NSOperation的操作依赖

NSOperation有一个非常好用的方法，就是操作依赖。可以从字面意思理解：某一个操作（operation2）依赖于另一个操作（operation1），只有当operation1执行完毕，才能执行operation2，这时，就是操作依赖大显身手的时候了。NSOperation 提供了3个接口供我们管理和查看依赖。

代码示例：A 执行完操作，B 才能执行操作。

- (void)useAddDependency{
    // 创建队列
    NSOperationQueue* queue = [[NSOperationQueue alloc] init];
    
    queue.maxConcurrentOperationCount = 4;//并行队列
    
    // 创建操作
    NSBlockOperation* A = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务A == %@ 第%d次执行",[NSThread currentThread],i); // 打印当前线程
        }
    }];
    
    NSBlockOperation* B = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务B == %@ 第%d次执行",[NSThread currentThread],i); // 打印当前线程
        }
    }];
    
    // 添加依赖
    [B addDependency:A];    // 让B依赖于A,则先执行A,再执行B.
    
    // 添加操作到队列中
    [queue addOperation:A];
    [queue addOperation:B];
}

执行结果:

执行结果
按照6.4.3所述，我们设置了queue.maxConcurrentOperationCount = 4 ;本应并行执行，但是设置依赖后，B等A执行完毕后才执行的。
6.6 NSOperation 优先级

NSOperation 提供了queuePriority(优先级)属性，queuePriority 属性适用于同一操作队列中的操作，不适用于不同操作队列中的操作。默认情况下，所有新创建的操作对象优先级都是NSOperationQueuePriorityNormal。但是我们可以通过setQueuePriority:方法来改变当前操作在同一队列中的执行优先级。

// 优先级的取值
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
    NSOperationQueuePriorityVeryLow = -8L,
    NSOperationQueuePriorityLow = -4L,
    NSOperationQueuePriorityNormal = 0,
    NSOperationQueuePriorityHigh = 4,
    NSOperationQueuePriorityVeryHigh = 8
};

对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。

6.7 NSOperation，NSOperationQueue 线程间的通信

在 iOS 开发过程中，我们一般在主线程里边进行 UI 刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。

//线程间通信
- (void)useMainQueue {
    // 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    
    // 添加操作
    [queue addOperationWithBlock:^{
        // 异步执行耗时操作
        for (int i = 0; i < 3; i++) {
            [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
            NSLog(@"任务1 == %@ 第%d次执行",[NSThread currentThread],i);
        }
        
        // 回到主线程
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            for (int i = 0; i < 2; i++) {
                [NSThread sleepForTimeInterval:1]; // 模拟耗时操作
                NSLog(@"任务2 == %@ 第%d次执行",[NSThread currentThread],i);
            }
        }];
    }];
}

执行结果：


执行结果

可以看出：通过线程间的通信，先在其他线程中执行操作，等操作执行完了之后再回到主线程执行主线程的相应操作。

6.8 NSOperation、NSOperationQueue 常用属性和方法归纳
6.8.1 NSOperation 常用属性和方法
6.8.2 NSOperationQueue 常用属性和方法

注意
这里的暂停和取消（包括操作的取消和队列的取消）并不代表可以将当前的操作立即取消，而是当当前的操作执行完毕之后不再执行新的操作。
暂停和取消的区别在于：暂停操作之后还可以恢复操作，继续向下执行；而取消操作之后，所有的操作都清空了，无法再接着执行剩下的操作。

总结：
借鉴很多内容，但是有些忘了是谁的，就不一一列举了。文章有点长，希望大家能耐心的看下来，如果发现问题，也希望大家积极指正，如有不足，也恳请大家告知，谢谢。

参考资料

参考文章
iOS多线程全套：线程生命周期，多线程的四种解决方案，线程安全问题，GCD的使用，NSOperation的使用
iOS 多线程: [NSOperation NSOperationQueue] 详解

上一篇 下一篇

猜你喜欢

热点阅读