2022iOS面试题之多线程

GCD特点：
1、GCD是基于c语言的用于多核的并行运算
2、GCD会自动利用更多的CPU内核（比如双核、四核）
3、GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
4、程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码

队列：串行队列：会顺序执行
         并行队列：可以并行执行
         全局队列：系统创建，全局并发队列
         主队列：主队列与主线程是绑定的

只要是同步的方式提交任务，无论是串行还是并发，就会在同一线程去执行。
同步：只能在当前线程中执行任务，不具备开启新线程的能力
异步：可以在新线程中执行任务，具备开启新线程的能力
———————————————————————————————
死锁

原因：主队列里sync 同步执行，就是会先阻塞当前线程，直到block 当中的代码执行完毕，但是block在viewdidload里面，block需要等待viewdidload执行完结束才能继续，但是viewdidload需要等待block执行完才能结束。
可以将同步改成异步dispatch_async,或者将dispatch_get_main_queue换成其他串行或并行队列，都可以解决。

- (void)viewDidLoad {
    [super viewDidLoad];
   //会死锁，都在主队列里同步执行
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"deallock");
    });
}
解决
- (void)viewDidLoad {
    [super viewDidLoad];
    //不会死锁，serialQueue虽然是串行队列，但不是主队列，serialQueue和viewDidLoad（在主队列执行）的执行队列不同就不会等待，
    dispatch_sync(serialQueue, ^{
        NSLog(@"deallock");
    });
}

———————————————————————————————
面试题：多读单写的GCD实现？异步栅栏到并发队列方案[就是像筑起一个栅栏一样，将队列中的多组线程任务分割开]

-(id)objectForKey: (NSString *) key{
　　__block id obi:
　　dispatch_queue_t concurrent_queue = dispatch_queue_create("barrier", DISPATCH_QUEUE_CONCURRENT); 
　　//同步读取指定数据,单读
　　dispatch_sync(concurrent_queue, ^{
　　　　obj= [userCenterDic obiectForKey: key];
　　});
　　return obi;
}
-(void)setobject: (id)obj forKey: (NSString *) key{

　　dispatch_queue_t concurrent_queue = dispatch_queue_create("barrier", DISPATCH_QUEUE_CONCURRENT);

 //异步栅栏调用设置数据，多写 　　
　　dispatch_barrier_async (concurrent_queue, ^{ 　
　　　[userCenterDic setobiect:obi forKey: key]; 　　
　　});
}
区别？
1、dispatch_barrier_sync需要等待自己的任务（barrier）结束之后，才会继续添加并执行写在barrier后面的任务（4、5、6），然后执行后面的任务
2、dispatch_barrier_async将自己的任务（barrier）插入到queue之后，不会等待自己的任务结束，它会继续把后面的任务（4、5、6）插入到queue，然后执行任务。

注意：在使用栅栏函数时.使用自定义队列才有意义,如果用的是串行队列或者系统提供的全局并发队列,这个栅栏函数的作用等同于一个同步函数的作用。

—————————————————————————————————
面试题：A/B/C任务并发执行完成后，再调用D任务?
在n个耗时并发任务都完成后，再去执行接下来的任务。比如，在n个网络请求完成后去刷新UI页面。
使用dispatch_group 队列组。

dispatch_queue_t concurrentQueue = dispatch_queue_create("test1", DISPATCH_QUEUE_CONCURRENT);
 
    dispatch_group_t group = dispatch_group_create();
    
    for (NSInteger i = 0; i < 10; i++) {
        
        dispatch_group_async(group, concurrentQueue, ^{
            
            sleep(1);
            
            NSLog(@"%zd:网络请求",i);
        });
    }
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        
        NSLog(@"刷新页面");
    });

——————————————————————————————
使用信号量，控制多线程下的同步操作。（作用：保证关键代码段不被并发调用。）

　　1. 初始化信号（initialize/create）
　　2. 发信号（signal/post）
　　3. 等信号（wait/suspend）
　　4. 释放信号（destroy）

    dispatch_semaphore_t sem = dispatch_semaphore_create(0);
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        
        NSLog(@"任务1:%@",[NSThread currentThread]);
        dispatch_semaphore_signal(sem);
    });
    
    dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"任务2:%@",[NSThread currentThread]);
        dispatch_semaphore_signal(sem);
    });
    
    dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"任务3:%@",[NSThread currentThread]);
    });

———————————————————NSOperation——————————————

特性：

1.Dependency 设置依赖，优先级
2.NSOperation 有如下几种的运行状态：状态控制
* Pending
* Ready
* Executing
* Finished
* Canceled
除 Finished 状态外，其他状态均可转换为 Canceled 状态。
3. maxConcurrentOperationCount,默认的最大并发 operation 数量是由系统当前的运行情况决定的(来源)，我们也可以强制指定一个固定的并发数量.
4、可以很方便的取消一个操作的执行。
5、使用KVO观察对操作执行状态的更改：isExecuting、isFinished、isCancelled。

NSOperation的任务状态

isReady 当前任务是否处于就绪状态

isExecuting 当前任务是否处于正在执行中状态

isFinished 当前任务是否已执行完毕

isCancelled 当前任务是否已取消

怎么去控制状态？重写main方法的话，底层帮我们自动控制的。重写start方法才是我们控制状态

1.如果只重写了NSOperation的main方法,底层会为我们控制变更任务执行完成状态，以及任务退出（后续线程的退出和NSOperation的退出）

2.如果重写了NSOperation的start方法,需要我们自行控制任务状态,在合适的时机去修改对应的isFinished等
 

    查看NSOperation的start方法源码,理解上面两点
    start方法内,首先创造一个自动释放池,然后获取线程优先级
    做一系列的状态异常判断,然后判断当前状态是否isExecuting
    如果不是,那么我们手动变成isExecuting,然后判断当前任务是否有被取消
    若未被取消就调用NSOperation的main方法
    再之后,调用NSOperation的finish方法。finish 方法中：在内部通过KVO的方式去变更isExecuting状态为isFinished状态
    之后调用自动释放池的release 

所以系统是在start方法里面为我们维护了任务状态的变更,若重写start,则没人帮我们维护了,只能自己手动维护

kvo监听状态属性的变化，来确定是否需要移除的,通过 KVO 监测 isExecuting 和 isFinished 这几个变量，来监测 Operation 的完成状态的

//设置优先级最高
    op1.qualityOfService = NSQualityOfServiceUserInteractive;

 //设置依赖 ： 列如：下载 解压  升级完成
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
            NSLog(@"下载");
    }];
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        [NSThread sleepForTimeInterval:2.0];
        NSLog(@"解压");
    }];
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
             NSLog(@"升级完成");
    }];
    //设置操作间的依赖
    [op2 addDependency:op1];
    [op3 addDependency:op2];
    //会发生循环依赖  ，什么都不操作
    //操作添加到队列中
    [self.queue addOperations:@[op1,op2] waitUntilFinished:NO];
    //依赖关系可以跨队列
    [[NSOperationQueue mainQueue] addOperation:op3];

GCD 与 NSOperation 的对比

* 首先要明确一点，NSOperationQueue 是基于 GCD 的更高层的封装.
* 从易用性角度，GCD 由于采用 C 风格的 API，在调用上比使用面向对象风格的 NSOperation 要简单一些。
* 从对任务的控制性来说，NSOperation 显著得好于 GCD，和 GCD 相比支持了 Cancel 操作（注：在 iOS8 中 GCD 引入了 dispatch_block_cancel 和 dispatch_block_testcancel，也可以支持 Cancel 操作了），支持任务之间的依赖关系，支持同一个队列中任务的优先级设置，同时还可以通过 KVO 来监控任务的执行情况。这些通过 GCD 也可以实现，不过需要很多代码，使用 NSOperation 显得方便了很多。
* 效率，直接使用 GCD 效率确实会更高效，NSOperation 会多一点开销，但是通过 NSOperation 可以获得依赖，优先级，继承，键值对观察这些优势
* 从第三方库的角度，知名的第三方库如 AFNetworking 和 SDWebImage 背后都是使用 NSOperation，也从另一方面说明对于需要复杂并发控制的需求，NSOperation 是更好的选择
————————————————————————————————————————————————
线程间通信：切换到主线程[NSOperationQueue mainQueue]

———————————————————NSThread———————————————————————————
NSThread在实际开发中比较常用到的场景就是去实现常驻线程。
将耗时操作放在子线程中，并且在子线程中开启runloop，并使子线程常驻，这样就能不停的执行耗时操作，并且不会影响到主线程啦，滑动tableview很丝滑

   NSThread *thread = [[NSThread alloc] initWithBlock:^{
    self.timer = [NSTimer scheduledTimerWithTimeInterval:0.35 repeats:YES block:^(NSTimer * _Nonnull timer) {
        NSLog(@"1234567");
        static int count = 0;
        [NSThread sleepForTimeInterval:1];
        //休息一秒钟，模拟耗时操作
    }];;
    [self.timer fire];
    [[NSRunLoop currentRunLoop] addTimer:self.timer forMode:NSDefaultRunLoopMode];
    [[NSRunLoop currentRunLoop] run];
}];
[thread start];

如何保证线程安全？
NSOperation的线程安全
和其他多线程方案一样，解决NSOperation多线程安全问题，可以给线程加锁，在一个线程执行该操作的时候，不允许其他线程进行操作。iOS 实现线程加锁有很多种方式。

@synchronized、
NSLock、
NSRecursiveLock、
NSCondition、
NSConditionLock、
pthread_mutex、
dispatch_semaphore、
OSSpinLock等等各种方式。

@synchronized一般在创建单例对象的时候使用，保证创建的对象是唯一的，但是性能没有dispatch_once_t好。

@implementation XXClass
//@synchronized来实现
+ (id)sharedInstance {
    static XXClass *sharedInstance = nil;
    @synchronized(self) {
        if (!sharedInstance) {
            sharedInstance = [[self alloc] init];
        }
    }
    return sharedInstance;
}


//dispatch_once_t来实现
@implementation XXClass

+ (id)sharedInstance {
    static XXClass *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[self alloc] init];
    });
    return sharedInstance;
}

@synchronized 的作用是创建一个互斥锁，保证此时没有其它线程对self对象进行修改，保证代码的安全性。也就是包装这段代码是原子性的，安全的。
这个是objective-c的一个锁定令牌，防止self对象在同一时间内被其他线程访问，起到保护线程安全的作用

1、

atomic：变量默认是有该有属性的，这个属性是为了保证在多线程的情况下，编译器会自动生成一些互斥加锁的代码，避免该变量的读写不同步的问题。　　
nonatomic：如果该对象无需考虑多线程的情况，这个属性会让编译器少生成一些互斥代码，可以提高效率。

2、使用GCD实现atomic操作：给某字段的setter和getter方法加上同步队列


3、使用NSLock


4、使用互斥锁
————————————————————————————————————————————————

//互斥锁 -- 保证锁内的代码在同一时间内只有一个线程在执行
        @synchronized (self){}

//使用NSLock

     NSLock* myLock=[[NSLock alloc]init];
    NSString *str=@"hello";
    [NSThread detachNewThreadWithBlock:^{
        [myLock lock];
        NSLog(@"%@",str);
        str=@"world";
        [myLock unlock];
     }];
    [NSThread detachNewThreadWithBlock:^{
        [myLock lock];
        NSLog(@"%@",str);
        str=@"变化了";
        [myLock unlock];
    }];

输出结果不加锁之前，两个线程输出一样 hello；加锁之后，输出分别为hello 与world。


“自旋锁OSSpinLock” & “互斥锁”的异同:
* 共同点
都能够保证线程安全
* 不同点


　　　　互斥锁：如果其他线程正在执行锁定的代码，此线程就会进入休眠状态，等待锁打开；然后被唤醒


　　　　自旋锁：如果线程被锁在外面，那么就会用死循环的方式一直等待锁打开！
　　　　自旋锁OSSpinLock用于轻量级的数据计算，如int型的+1、-1，在内存管理里面，对引用计数器的加减就使用了自旋锁。


递归锁NSRecursiveLock，可以重入，不会造成死锁。
NSLock不可以重入，会造成死锁。

换成递归锁就不会导致死锁了。


线程间通信
对于线程间通信常见的是线程间同步控制，比如通过线程锁、GCD队列、NSOperationQueue操作队列；
若涉及到线程间同步传递数据，最有效的方式是通过共享的进程内存并结合线程锁来控制数据同步；
若涉及到线程间异步传递数据，可通过mach port或者performSelector:onThread:withObject:waitUtilDone:并结合runloop来实现。
传递数据大小而言，对于大容量数据，一般会存储到临时文件并传递文件描述符；
具体的线程间通信方式需要根据实际的使用场景来选择，如同步/异步、传递数据大小、单向/双向通信等。

performSelector实现线程间通信（实现子线程和主线程互相通信，前提是子线程需要保活。【https://www.jianshu.com/p/eae43bdb7eb8】）
NSPort实例 实现线程间通信

案列：图片下载的案列，在子线程下载图片，在主线程更新UI

其他：

PerformSelector 的实现原理？

当调用 NSObject 的 performSelecter:afterDelay: 后，实际上其内部会创建一个 Timer 并添加到当前线程的 RunLoop 中。所以如果当前线程没有 RunLoop，则这个方法会失效。

当调用 performSelector:onThread: 时，实际上其会创建一个 Timer 加到对应的线程去，同样的，如果对应线程没有 RunLoop 该方法也会失效。