iOS面试之多线程模块

多线程

多线程内容如下:

• GCD
• NSOperation
• NSThread
• 多线程与锁

多线程.png

1.GCD

- 同步/异步 和 串行/并发
- dispatch_barrier_async
- dispatch_group

• 同步/异步和串行/并发

//同步分派一个任务到串行队列
- dispatch_sync(serial_queue,^{//任务});
//异步废牌一个任务到串行队列
- dispatch_async(serial_queue,^{//任务});
//同步分派一个任务到并发队列
- dispatch_sync(concurrent_queue,^{//任务})
//异步分派一个任务到并发队列
- dispatch_async(concurrent_queue,^{//任务})

• 同步串行

-(void)viewDidload{
     dispatch_sync(dispatch_get_main_queue(),^{
         [self doSomething];
     });
}
//产生死锁
原因:队列引起的循环等待

队列引起的循环等待.png

- 主队类先提交一个viewDidLoad,接着提交一个Block
- 两个任务都要提交到主线程去执行
- 我们分派viewDidLoad到主线程处理,需要调用Block,当Block同步调用完成之后,
viewDidLoad方法才可以继续向下执行
- viewDidLoad方法的调用结束,需要依赖于后续提交的Block任务
- Block想执行,需要依赖主队列先进先出的性质,需要等待ViewDidLoad的完成
- Block想要处理,依赖于ViewDidLoad的完成
- 所以,形成了相互等待

-(void)viewDidload{
     dispatch_sync(serialQueue,^{
         [self doSomething];
     });
}
//没问题

同步串行.png

- viewDidLoad方法提交到主队列当中,会运行处理到主线程中
- viewDidLoad执行到某一时刻,需要同步提交一个任务到串行队列
- 串行队列其实是同步方式提交的,在当前线程执行,最终在主线程执行
- 串行队列任务,在主线程提交完成后,再到主队类完成viewdidload其他任务

• 同步并发

-(void)viewDidLoad{
           NSLog(@"1");
           dispatch_sync(global_queue,^{
                 NSLog(@"2");
                 dispatch_sync(global_queue,^{
                         NSLog(@"3");
                 });
                 NSLog(@"4");
           });
           NSLog(@"5");
}

//12345
//同步分派任务在当前线程中执行

• 异步串行

-(void)viewDidload{
     dispatch_async(dispatch_get_main_queue(),^{
         [self doSomething];
     });
}

• 异步并发

-(void)viewDidload{
     dispatch_async(global_queue,^{
         NSLog(@"1");
         [self performSelector:@selector(logPrint)] withObject: nil afterDelay:0];
         NSLog(@"3");
     });
}
-(void)logPrint{
      NSLog(@"2");
}

//13
- 我们通过异步方式分派到全局并发队列中,本身block,会在GCD维护的线程池当中进行执行,处理.GCD默认并没有开启runloop
- performSelector: withObject: afterDelay: 延迟0秒提交Selector任务,需要相应创建提交runloop任务的逻辑的
- GCD创建的线程没有runloop的情况下, performSelector方法就会失效

• dispathc_barrier_async()
  如何使用GCD实现多读单写?

读写数据.png

- 读者,读者并发(实现多读)
- 读者,写着互斥(有读取数据的时候,不能存在写者写数据)
- 写着,写着互斥(有一个写线程在写数据,另一个写线程就不能写数据)

多读单写.png

dispathc_barrier_async(concurrent_queue,^{//写操作});

#import "User.h"

@interface User()
{
    // 定义一个并发队列
    dispatch_queue_t concurrent_queue;
    // 用户数据中心, 可能多个线程需要数据访问
    NSMutableDictionary *userDic;
}

@end
// 多读单写模型
@implementation User

- (id)init
{
    self = [super init];
    if (self) {
        // 通过宏定义 DISPATCH_QUEUE_CONCURRENT 创建一个并发队列
        concurrent_queue = dispatch_queue_create("read_write_queue", DISPATCH_QUEUE_CONCURRENT);
        // 创建数据容器
        userDic = [NSMutableDictionary dictionary];
    }
    
    return self;
}

- (id)objectForKey:(NSString *)key
{
    __block id obj;
    // 同步读取指定数据
    dispatch_sync(concurrent_queue, ^{
        obj = [userDic objectForKey:key];
    });
    return obj;
}

- (void)setObject:(id)obj forKey:(NSString *)key
{
    // 异步调用设置数据
    dispatch_barrier_async(concurrent_queue, ^{
        [userDic setObject:obj forKey:key];
    });
}

• Dispatch_group_async()

使用GCD实现:A,B,C三个任务并发,完成后执行任务D

Dispatch_group_async.png

#import "Group.h"

@interface Group()
{
    dispatch_queue_t concurrent_queue;
    NSMutableArray <NSURL *> *arrayURLs;
}

@end

@implementation Group

- (id)init
{
    self = [super init];
    if (self) {
        // 创建并发队列
        concurrent_queue = dispatch_queue_create("concurrent_queue", DISPATCH_QUEUE_CONCURRENT);
        arrayURLs = [NSMutableArray array];
    }
    return self;
}

- (void)handle
{
    // 创建一个group
    dispatch_group_t group = dispatch_group_create();
    
    // for循环遍历各个元素执行操作
    for (NSURL *url in arrayURLs) {
        // 异步组分派到并发队列当中
        dispatch_group_async(group, concurrent_queue, ^{
            //根据url去下载图片
            NSLog(@"url is %@", url);
        });
    }
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 当添加到组中的所有任务执行完成之后会调用该Block
        NSLog(@"全部下载完成");
    });
}
@end

2.NSOperation

需要与NSOperationQueue配合使用来实现多线程方案

优势特点:
- 添加任务依赖
- 任务执行状态控制
- 最大并发量

• 任务执行状态控制

状态有哪些?
- isReady 当前任务的就绪状态
- isExecuting 当前任务是否正在执行中
- isFinished 当前任务是否已经执行完成
- isCancelled 当前任务是否已经取消

状态控制
如果只重写main方法,底层控制变更任务执行完成状态,以及任务退出
如果重写了start方法,自行控制任务状态

系统是怎样移除一个isFinished=YES的NSOperation的?
通过KVO

3.NSThread

NSThread启动流程.png

start()
|
main()
|
perfomSelector
|
exit(结束线程)

4.多线程与锁

在日常开发中,都使用过哪些锁?
- @synchronized
- atomic
- OSSpinLock
- NSRecursiveLock
- NSLock
- dispatch_semaphore_t

• @synchronized

- 一般在创建单例对象的时候使用
- 多线程环境下创建线程是唯一的

• atomic

- 修饰属性的关键字
- 对被修饰对象进行原子操作(不负责使用)

@property(atomic) NSMutableArray *array;
self.array = [NSMutableArray array];//这样保证线程的安全性
[self.array addObject:obj];//不能保证线程安全的

• OSSpinLock

- 自旋锁
- 循环等待访问,不释放当前资源
- 用于轻量级数据访问(引用计数+1/-1操作)

• NSLock

-(void)A{
    [lock lock];
    [self B];
    [lock unlock];
}

-(void)B{
   [lock lock];
   //操作逻辑
   [lock unlock];
}
//导致死锁
- 使用NSLock 对临界区加锁处理的时候,当前某个线程调用lock之后,获取得到锁
- 到B方法后,同一把锁友获取了一次,导致了死锁

//解决方案
通过递归锁NSRecursiveLock

• NSRecursiveLock

-(void)A{
    [recursiveLock lock];
    [self B];
    [recursiveLock unlock];
}

-(void)B{
   [recursiveLock lock];
   //操作逻辑
   [recursiveLock unlock];
}

递归锁的特点就是重入

• dispatch_semaphore_t

- 信号量
- dispatch_semaphore_create(1);
- dispatch_semaphore_wait(semaphore,DISPATCH_TIME_FOREVER);
- dispatch_semaphore_signal(semaphore);

面试题:

• 怎样用GCD实现多读单写?
• iOS系统为我们提供几种多线程技术各自特点是怎样的?
• NSOperation对象在isFinished之后是怎样从queue当中移除掉的?
• 用过哪些锁?你是怎样使用的?

QQ交流群: 796142709