iOS小结之多线程

小结第三篇,来总结总结iOS中多线程操作。

线程概述

对于ios系统中的某个App来讲,是单进程多线程方式来工作。一般来说,使用多线程的好处是可以把程序分成相对独立的几个模块,可以有效的防止某个模块堵塞的时候导致整个程序卡死;还有就是提高运行效率,现在CPU都是多核,多个核可以同时跑,可以同时执行多条线程。

谈细节之前里,我们得说下有关多线程的几个概念。

串行和并发

串行的意思是在多个任务下,每次只会有一个任务被执行,并发的意思是同一时间多个任务同时发生。并发是一种现象,解决并发现象的技术,叫做并行。我们经常说的多线程编程,说的就是并行技术,可以让多个CPU同时执行,加快执行速度,提高执行效率。

同步和异步

同步的意思是在多任务中,一个任务只能等待另一个任务完成之后,他才可以进行,而异步的意思是一个任务的执行,不需要等待上一个任务的执行,不会发生堵塞。

临界区

临界区是一种资源,这块资源不能并发执行,就叫做临界区。我们一般所看到的,临界区就是一个代码块。因为临界区资源如果可以被多个线程同时进行操作,比如读写,就可能出现异常。

死锁就是指两条线程互相都在等待对方执行完毕,才能进入下一步操作。由于两条线程都不能执行下一步,所以造成死锁,卡住不动了。

线程安全

线程安全在iOS开发中应该听到多很多次,指的是在多线程中或者并发任务中可以被安全地调用,就称为线程安全。比如NSDictionary就是线程安全的,可以在多线程中使用它,不会出现问题,而NSMutableDictionary是线程不安全的,所以使用NSMutableDictionary的时候应该保证每次只能有一个线程访问它。

上下文切换

上下文切换指的是在一条进程中切换不同线程时,线程的等待和恢复执行的过程。这一过程中会带来一些额外的开销。

iOS多线程方案

Pthreads

Pthreads是基于C语言的通用多线程API,在日常开发中基本上用不到,并且目前在Swift中貌似并不能直接调用这套API。所以这种方案只提一下,不过多介绍。

NSThread

NSThread是一套比较轻量级的多线程方案,可以直观地控制线程对象,一个NSThread代表一条线程,但是需要自己管理线程的生命周期,线程同步等问题,

创建thread目前所了解到的有4种方式,其中类方法两个,实例方法两个。类方法创建线程后会自动启动该线程,而实例方法只会创建线程,启动需要手动去做。

// 第一种类方法[NSThread detachNewThreadSelector:@selector(threadHandler) toTarget:self withObject:nil];4- (void)threadHandler {    NSThread *currentThread = [NSThread currentThread];    NSLog(@"current thread: %@", currentThread);}// 第二个类方法[NSThread detachNewThreadWithBlock:^{    NSLog(@"block current thread: %@", [NSThread currentThread]);}];

下面是两种实例方法:

// 第一个实例方法NSThread *thread1 = [[NSThread alloc] initWithBlock:^{    NSLog(@"current thread: %@", [NSThread currentThread]);}];[thread1 start];// 第二个实例方法NSThread *thread2 = [[NSThread alloc] initWithTarget:self selector:@selector(threadHandler:) object:@{@"title" : @"2123"}];[thread2 start];4- (void)threadHandler:(NSDictionary *)dic {    NSThread *currentThread = [NSThread currentThread];    NSLog(@"current thread: %@", currentThread);}

除了上面的之外,NSThread还提供了一个NSObject+NSThreadPerformAdditions,用于在NSObject中执行线程调用:

// 在主线程执行一个任务,后者区别在于可以指定在哪种Runloop模式下运行,有关Runloop可以参考上篇文章。[self performSelectorOnMainThread:@selector(threadHandler:) withObject:@{@"title" : @"123"} waitUntilDone:YES];
[self performSelectorOnMainThread:@selector(threadHandler:) withObject:@{@"title" : @"123"} waitUntilDone:YES modes:@[NSDefaultRunLoopMode]];// 在指定的线程中执行一个任务。[self performSelector:@selector(threadHandler:) onThread:[NSThread currentThread] withObject:@{@"title" : @"123"} waitUntilDone:YES];
[self performSelector:@selector(threadHandler:) onThread:[NSThread currentThread] withObject:@{@"title" : @"123"} waitUntilDone:YES modes:@[NSDefaultRunLoopMode]];// 在后台隐形创建线程,执行一个任务[self performSelectorInBackground:@selector(threadHandler:) withObject:@{@"title" : @"123"}];

- (void)threadHandler:(NSDictionary *)dic {
    NSThread *currentThread = [NSThread currentThread];
    NSLog(@"current thread: %@", currentThread);
}

另外,NSThread还提供了设置线程优先级功能,叫做NSQualityOfService,一共分为一下几种:

  • NSQualityOfServiceUserInteractive。用于用户交互,最高优先级

  • NSQualityOfServiceUserInitiated。用于执行需要立即返回的的任务,次高优先级

  • NSQualityOfServiceDefault。线程默认优先级

  • NSQualityOfServiceUtility。用于执行普通任务,普通优先级

  • NSQualityOfServiceBackground。最低优先级,用于执行不重要的任务

还有其他一些线程操作,具体如下:

// 线程休眠,休眠线程会阻塞当前线程
[NSThread sleepForTimeInterval:5.0];
[NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:5.0]];// 线程取消,调用此方法并不会马上停止线程运行,只仅仅是线程状态记录
[thread cancel];// 线程停止,执行此方法会立即终止主线程外其他所有线程,所以调用请慎用。
[NSThread exit];// 获取当前线程
[NSThread currentThread];// 获取主线程
[NSThread mainThread];// 停止当前线程的Runloop
CFRunLoopStop(CFRunLoopGetCurrent());

如果有多个线程共享一块资源,对资源进行操作时候,还涉及到线程同步问题,一段时间只允许一条线程来操作资源,不然会引起冲突,iOS实现线程加锁有NSLock和@synchronized两种方式。其用法也比较简单,在这里就不过多介绍。

GCD

GCD全称是Grand Central Dispatch,是为了给iOS和mac的多核硬件上执行支持,其实现方式是一套底层C API。通过GCD,开发者不用和线程打交道,只需要使用一个Block就可以实现多线程操作。GCD提供的API简单易懂,提供了一个易于使用的并发模型,对于开发者来说,并不需要关心多线程的并发问题,GCD底层自动处理这些逻辑。

出了这些之外,GCD其实还可以根据当前的系统负载来增减线程数量,我们都知道线程的创建切换都是需要代价的,是有消耗的,所以使用GCD还可以增加效率,提供更高的性能。

GCD操作是需要通过队列来操作的,有三种队列可以使用。

  • 串行队列(Serial)。串行队列的特点是以先进先出的顺序来执行的,队列内的东西是以顺序执行的,但是多个串行队列直接是以并发执行的。

  • 并行队列(Concurrent)。并行队列和串行队列相反,可以同时执行多个任务,但是多个任务之间,仍然是以先进先出的顺序执行的,区别在于,并行队列会跟酒系统负载,尽可能多地创建线程去执行这些任务。但是哪个任务先执行完毕是不确定的。

  • 主线程队列(Main dispatch queue)。实际上,主线程队列是一个和主线程相关的串行队列。这个队列中的任务每次只会有一个执行。可以保证所有的任务都会在主线程执行,所以涉及到UI操作的需要使用这个队列来完成。

创建一个串行队列,如下所示:

dispatch_queue_t queue = dispatch_queue_create(@"com.hyyy.gcd", DISPATCH_QUEUE_SERIAL);// 这种也可以,NULL默认就是串行dispatch_queue_t queue = dispatch_queue_create("com.hyyy.gcd", NULL);

创建一个并行队列,如下所示:

dispatch_queue_t queue = dispatch_queue_create("coml.hyyy.gcd", DISPATCH_QUEUE_CONCURRENT);// 也可以用下面这种dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

主线程队列:

dispatch_queue_t queue = dispatch_get_main_queue();

GCD往队列里添加任务有两种方式,一种是异步,一种是同步。

  • 异步(dispatch_async)。是一个异步添加操作,dispatch_async会立即返回;

  • 同步(dispatch_sync)。是一个同步添加操作,dispatch_sync区别是会阻塞当前线程,会等待block里的任务执行完毕之后才会返回。

dispatch_async添加任务,会立即返回,所以下面的打印顺序不确定。

dispatch_async(dispatch_get_main_queue(), ^{    NSLog(@"========1");

});NSLog(@"========2");// 执行结果:ThreadTest[17614:2597588] ========2ThreadTest[17614:2597588] ========1

如果是dispatch_sync,由于是同步,所以打印结果是有顺序的。

dispatch_queue_t queue = dispatch_queue_create("com.hyyy.gcd", NULL);dispatch_sync(queue, ^{    NSLog(@"========1");

});NSLog(@"========2");// 执行结果ThreadTest[17599:2595130] ========1ThreadTest[17599:2595130] ========2
但是dispatch_sync尽量少用,使用不当会造成死锁。比如下面的代码就会造成死锁:
dispatch_sync(dispatch_get_main_queue(), ^(void){
   NSLog(@"这里死锁了");});

需要注意的是,死锁并不是这里使用了主线程造成的,不用主线程,照样可以造成死锁。如下:

dispatch_queue_t serialQueue = dispatch_queue_create("com.hyyy.thread", DISPATCH_QUEUE_SERIAL);NSLog(@"========1");dispatch_async(serialQueue, ^{
   NSLog(@"========2");
   dispatch_sync(serialQueue, ^{
       NSLog(@"========3");
   });});

这种也会发生死锁,所以不要听信什么主线程的问题,不是主线程照样可以发生死锁。死锁真的发生的原因是dispatch_sync添加进的queue队列是当前queue队列。在主线程死锁的那段代码中,我们调用的dispatch_sync是添加在主线程queue中,使主线程堵塞,而我们的Block又需要主线程queue来执行,所以相互等待,造成死锁了。

但是为什么添加队列换成并行队列就不会有问题呢?还是上面的概念,对于并行队列中任务的执行,其执行开始和结束并不取决于上一个任务的结束时间,只仅仅取决于任务的耗时。即便任务是以同步的方式添加进去,但是在并行队列中也会在另外一个线程去跑这个任务。

这里还需要提一个题外话,在并发队列里的Block何时执行,开发者是不用知道的,完全取决于GCD,但是我们也是有方法可以让其按照顺序执行。

GCD的使用场景有很多,我们一个一个举例来说明。

后台下载显示图片

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{    NSURL * url = [NSURL URLWithString:@"http://www.yourimage.com"];    NSError * error;    NSString * data = [NSString stringWithContentsOfURL:url encoding:NSUTF8StringEncoding error:&error];    if (data != nil) {        dispatch_async(dispatch_get_main_queue(), ^{            self.imageView.image = [UIImage imageWithData:data];
       });
   } else {        NSLog(@"error when download:%@", error);
   }
});

这是一个经典的使用场景,有时候我们需要后台处理一个任务,然后在主线程进行UI渲染,可以这么干。

单例模式

单例模式是设计模式中最简单的一种了,它的目的是创建的类对象在系统中是唯一的,一个类只有一个实例,节约系统资源。一般我们创建一个单例会这么做:

//Singleton.h@interface Singleton : NSObject+ (Singleton *)sharedInstance;@end//Singleton.m@implementation Singletonstatic Singleton * sharedSingleton = nil;
+ (Singleton *) sharedInstance {    static dispatch_once_t onceToken;    dispatch_once(&onceToken, ^{
       sharedSingleton = [[Singleton alloc] init];
   });    return sharedSingleton;
}@end

这里我们用到了dispatch_once_t,对于给定的token来说,Block里的代码必定会执行,并且会仅执行一次。最重要的一点是,这里的操作是线程安全的,十分高效。但是需要注意的是token这个东西是应该声明称static或者global,这样来保证每次传进去的token是相同的。

dispatch_after延后执行

dispatch_after可以做到使一块代码延时执行,但是需要注意的是,这里的延时是有歧义的,dispatch_after做到的仅是延时把这一项任务提交到队列中去,至于什么时候执行,是和GCD内部处理逻辑有关的。

比如我想0.5秒之后发送一条通知,可以这么干。

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{    [[NSNotificationCenter defaultCenter] postNotificationName:HY_AFTER_NOTIFICATION object:nil];
});

dispatch_apply快速迭代

dispatch_apply和遍历的效果差不多,其作用是把指定次数的block添加到queue中,好处是dispatch_apply可以不用管理线程方面的问题,GCD会自动处理并发现象。

NSArray *array = @[@"a", @"b", @"c", @"d", @"e", @"f", @"g"];dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_apply(array.count, queue, ^(size_t i) {
   NSString *str = [array objectAtIndex:i];
   NSLog(@"number: %@", str);
});

Dispatch_groups

Dispatch_groups作用是用来监视多个并行任务的执行,来进行线程同步的。在多个任务执行完毕后,想要执行结束处理,就可以使用Dispatch_groups来完成。

dispatch_queue_t queue1 = dispatch_queue_create("com.hyyy.gcd", DISPATCH_QUEUE_CONCURRENT);
dispatch_queue_t queue2 = dispatch_get_global_queue(0, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue1, ^{
   NSLog(@"========1");
});
dispatch_group_async(group, queue1, ^{
   NSLog(@"========2");
});
dispatch_group_async(group, queue2, ^{
   NSLog(@"========3");
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
   NSLog(@"========end");
});

// 运行结果
========3========1========2========end

可以看到,上面三个任务执行完毕之后,才会走最后一个block回调,我们可以利用这种模式做很多事。但是千万不要像下面这么写:

dispatch_queue_t queue1 = dispatch_queue_create("com.hyyy.gcd", DISPATCH_QUEUE_CONCURRENT);dispatch_queue_t queue2 = dispatch_get_global_queue(0, 0);dispatch_group_t group = dispatch_group_create();dispatch_group_async(group, queue1, ^{    dispatch_async(queue2, ^{
       NSLog(@"========1");
   });});dispatch_group_async(group, queue1, ^{    dispatch_async(queue2, ^{
       NSLog(@"========2");
   });});dispatch_group_notify(group, dispatch_get_main_queue(), ^{
   NSLog(@"========end");});

这么写会有问题,dispatch_group_async里执行的是异步任务,而dispatch_group_notify并不会等待异步任务完成,如果真的这么做,那就需要dispatch_group_enter和dispatch_group_leave来进行约束,也是我用的比较多的一种。

dispatch_queue_t queue = dispatch_get_global_queue(0, 0);dispatch_group_t group = dispatch_group_create();dispatch_group_enter(group);dispatch_async(queue, ^{
   sleep(3);
   NSLog(@"========1");
   dispatch_group_leave(group);});dispatch_group_enter(group);dispatch_async(queue, ^{
   sleep(3);
   NSLog(@"========2");
   dispatch_group_leave(group);});dispatch_group_notify(group, dispatch_get_main_queue(), ^{
   sleep(3);
   NSLog(@"========end");});

需要注意的事,dispatch_group_enter和dispatch_group_leave总是对应出现的,类似于引用计数原理,有加有减。

dispatch_barrier并发问题

在并行队列里,有时候我们需要每次只单独执行一个任务,也就是当有个任务执行的时候,不允许其他任务执行,类似于多线程读写问题,这时候Dispatch Barrier就发挥了作用。

Dispatch Barrier可以保证提交的block是指定队列里某个时段唯一执行的一个,下面用一个示例来演示一下:

dispatch_queue_t dataQueue = dispatch_queue_create("com.hyyy.gcd", DISPATCH_QUEUE_CONCURRENT);dispatch_async(dataQueue, ^{
   [NSThread sleepForTimeInterval:2.f];    NSLog(@"读数据");
});dispatch_async(dataQueue, ^{    NSLog(@"读数据");
});//等待前面的都完成,在执行barrier后面的dispatch_barrier_async(dataQueue, ^{    NSLog(@"写数据");
   [NSThread sleepForTimeInterval:1];
});dispatch_async(dataQueue, ^{
   [NSThread sleepForTimeInterval:1.f];    NSLog(@"读数据");
});dispatch_async(dataQueue, ^{    NSLog(@"读数据");
});

在进行写数据的时候,因为使用了Dispatch Barrier,不会发生读数据的操作,所以保证了每次写入数据只会有一个任务在执行。

NSOperation

相比于GCD,NSOperation显得并没有那么流行,但是称得上是先进的面向对象的多线程解决办法。同样,对于开发者来讲,我们根本不用考虑线程的生命周期、同步,加锁等晦涩问题。

使用NSOperation有三种方式,NSInvocationOperation、NSBlockOperation和自定义子类继承NSOperation。

NSInvocationOperation

NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(operationHandler) object:nil];
[operation start];
5
- (void)operationHandler {    NSLog(@"current thread: %@", [NSThread currentThread]);    NSLog(@"main thread: %@", [NSThread mainThread]);
}// 运行结果current thread:{number = 1, name = main}
main thread:{number = 1, name = main}

NSInvocationOperation默认情况下,并不会新开一个线程去跑,而是在当前线程去执行任务,可以将NSInvocationOperation放到NSOperationQueue中,即可实现异步操作。

NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(operationHandler) object:nil];NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:operation];

- (void)operationHandler {    NSLog(@"current thread: %@", [NSThread currentThread]);    NSLog(@"main thread: %@", [NSThread mainThread]);
}// 运行结果current thread:{number = 3, name = (null)}
main thread:{number = 1, name = (null)}

NSBlockOperation

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{    NSLog(@"current thread: %@", [NSThread currentThread]);    NSLog(@"main thread: %@", [NSThread mainThread]);
}];
[operation start];// 运行结果current thread:{number = 1, name = main}
main thread:{number = 1, name = main}

和NSInvocationOperation一样,默认NSBlockOperation只会在当前线程上执行。如果需要新开线程操作,可以添加到NSOperationQueue中即可。

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{    NSLog(@"current thread: %@", [NSThread currentThread]);    NSLog(@"main thread: %@", [NSThread mainThread]);
}];NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:operation];// 运行结果current thread:{number = 3, name = (null)}
main thread:{number = 1, name = (null)}

另外,可以使用addExecutionBlock添加额外的操作。

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
   NSLog(@"current thread: %@", [NSThread currentThread]);
}];
[operation addExecutionBlock:^{
   NSLog(@"current thread: %@", [NSThread currentThread]);
}];
[operation addExecutionBlock:^{
   NSLog(@"current thread: %@", [NSThread currentThread]);
}];
[operation addExecutionBlock:^{
   NSLog(@"current thread: %@", [NSThread currentThread]);
}];
[operation start];// 运行结果current thread:{number = 1, name = main}
current thread:{number = 5, name = (null)}
current thread:{number = 4, name = (null)}
current thread:{number = 3, name = (null)}

可以看到,使用addExecutionBlock会在新线程中去执行。但是并不是每次都会创建,我们可以试下多创建几个:

NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
   NSLog(@"current thread: %@", [NSThread currentThread]);
}];
[operation addExecutionBlock:^{
   NSLog(@"current thread: %@", [NSThread currentThread]);
}];
[operation addExecutionBlock:^{
   NSLog(@"current thread: %@", [NSThread currentThread]);
}];
[operation addExecutionBlock:^{
   NSLog(@"current thread: %@", [NSThread currentThread]);
}];
[operation addExecutionBlock:^{
   NSLog(@"current thread: %@", [NSThread currentThread]);
}];
[operation addExecutionBlock:^{
   NSLog(@"current thread: %@", [NSThread currentThread]);
}];
[operation addExecutionBlock:^{
   NSLog(@"current thread: %@", [NSThread currentThread]);
}];
[operation addExecutionBlock:^{
   NSLog(@"current thread: %@", [NSThread currentThread]);
}];
[operation addExecutionBlock:^{
   NSLog(@"current thread: %@", [NSThread currentThread]);
}];
[operation addExecutionBlock:^{
   NSLog(@"current thread: %@", [NSThread currentThread]);
}];
[operation start];// 运行结果current thread:{number = 1, name = main}
current thread:{number = 1, name = main}
current thread:{number = 1, name = main}
current thread:{number = 1, name = main}
current thread:{number = 4, name = (null)}
current thread:{number = 1, name = main}
current thread:{number = 1, name = main}
current thread:{number = 1, name = main}
current thread:{number = 3, name = (null)}
current thread:{number = 5, name = (null)}

所以,如果NSBlockOperation封装的操作数大于1的时候,才会执行异步操作.不然也是在当前线程下执行的。

另外,NSOperation可以取消的,这个算是一大特色了,也是NSOperation的使用场景之一了。NSOperation有三种状态,isReady -> isExecuting -> isFinish, 如果在Ready的状态中对NSOperation进行取消,NSOperation会进入Finish状态。但是Operation已经开始执行了,就会一直运行到结束,或者由我们进行取消。也就是说Operation已经在executing状态,我们调用cancle方法系统不会中止线程的,这需要我们在任务过程中检测取消事件,并中止线程的执行,还要注意一点我们要释放内存或资源。

需要注意的是,调用cancel并不会退出线程,需要自行终止线程的运行。

if (![operation isCancelled]) {    [operation cancel];
}

还有,NSOpertion可以设置优先级,从而改变其执行顺序,我们举个例子。

NSOperationQueue *queue = [[NSOperationQueue alloc] init];NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{    NSLog(@"operation1后执行");
}];NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{    NSLog(@"operation2先执行");
}];
[operation1 addDependency:operation2];
[queue addOperation:operation1];
[queue addOperation:operation2];// 运行结果operation2先执行
operation1后执行

但是不能互相添加依赖,不然就死锁了,两个永远都不会执行。

[operation1 addDependency:operation2];[operation2 addDependency:operation1];

有些时候,我们需要监听到任务完成后的回调事件,NSOperation也提供了这个方法,叫CompletionBlock。

NSOperationQueue *queue = [[NSOperationQueue alloc] init];NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{    NSLog(@"operation1执行");
}];
[operation1 setCompletionBlock:^{    NSLog(@"operation1执行完毕");
}];NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{    NSLog(@"operation2执行");
}];
[operation2 setCompletionBlock:^{    NSLog(@"operation2执行完毕");
}];
[queue addOperation:operation1];
[queue addOperation:operation2];// 运行结果operation2执行
operation1执行
operation2执行完毕
operation1执行完毕

还有自定义NSOperation,由于不是经常能用到,所以就不多做介绍了。

总结

iOS多线程就总结到这里了,不过一般开发中用的GCD比较多,偶尔会用到NSOperation,这两个理解了就够用了,根据需求来定技术方案。

PS:如果您想和业内技术大牛交流的话,请加qq群(527933790)或者关注微信公众 号(AskHarries),谢谢!

转载请注明原文出处:Harries Blog™ » iOS小结之多线程

赞 (0)

分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址