IOS01-多线程底层

作者: 春风依旧 | 来源:发表于2019-07-14 14:33 被阅读0次

IOS01-多线程底层
iOS面试题--网络多线程
底层-多线程
iOS----GCD
iOS 多线程: NSThread的介绍
Java入门系列09 -- 多线程，I/O
iOS面试题锦集（一）——多线程网络
iOS 多线程
多线程网络
01-关于多线程&网络

一、多线程基础知识回顾

1、iOS中常见多线程方案

多线程方案.png

2、iOS中常见多线程方案

GCD中两个执行任务的函数(queue：队列 block：任务)

2.1 GCD中两个执行任务的函数

同步执行的方式

 // 在当前线程中执行任务，不具备开启新线程的能力
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

异步执行的方式

   // 在新的线程中执行任务，具备开启新线程的能力
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

2.2 GCD中的队列

并发队列（Concurrent Dispatch Queue）

  * 可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
  * 并发功能只有在异步（dispatch_async）函数下才有效

串行队列（Serial Dispatch Queue）

  * 让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）

2.3 各种队列和任务的执行效果执行效果.png

注意：

  * 使用sync函数往当前串行队列中添加任务，会卡住当前的串行队列（产生死锁）
  * 全局并发队列，内存中只有一个

2.4 队列组的使用

    //创建队列组
    dispatch_group_t group = dispatch_group_create();
    //创建并发队列
    dispatch_queue_t queue = dispatch_queue_create("my_queue", DISPATCH_QUEUE_CONCURRENT);
    //添加异步任务
    dispatch_group_async(group, queue, ^{
        for (int i = 0; i < 5; i++) {
            NSLog(@"任务1-%@",[NSThread currentThread]);
        }
    });
    dispatch_group_async(group, queue, ^{
        for (int i = 0; i < 1000; i++) {
            NSLog(@"任务2-%@",[NSThread currentThread]);
        }
    });
    // 等前面的任务执行完毕后，会在当前队列中执行任务
        dispatch_group_notify(group, queue, ^{
            dispatch_async(dispatch_get_main_queue(), ^{
                for (int i = 0; i < 5; i++) {
                    NSLog(@"任务3-%@", [NSThread currentThread]);
                }
            });
        });

二、多线程同步方案（解决安全隐患）

1、OSSpinLock
2、os_unfair_lock
3、pthread_mutex
4、dispatch_semaphore
5、dispatch_queue(DISPATCH_QUEUE_SERIAL)
6、NSLock
7、NSRecursiveLock
8、NSCondition
9、NSConditionLock
10、@synchronized

1、OSSpinLock：在 iOS10开始被废弃

1.1、"自旋锁"，等待锁的线程会处于忙等（busy-wait）状态，一直占用着CPU资源(相当于while循环阻塞线程)
1.2、目前已经不再安全，可能会出现优先级反转问题：

当有多条线程的时候，优先级比较高的线程会优先占用lock(锁)，优先级相对较低的线程就无法加锁，只有等优先级高的线程先执行完才可以进行加锁和解锁。

1.3、使用

导入头文件#import <libkern/OSAtomic.h>
定义锁   
@property(nonatomic,assign) OSSpinLock lock;
// 初始化锁
self.lock = OS_SPINLOCK_INIT;
// 加锁
OSSpinLockLock(&_lock);

加锁 和 解锁 中间放 多个线程访问的资源
// 解锁
OSSpinLockUnlock(&_lock);

2、os_unfair_lock（互斥锁）

2.1、从iOS10开始取代OSSpinLock
2.2、从底层调用看，等待os_unfair_lock锁的线程会处于休眠状态，并非忙等
2.3、需要导入头文件 #import <os/lock.h>
2.4、os_unfair_lock的使用：

导入头文件 #import <os/lock.h>
定义锁   
@property(nonatomic,assign) os_unfair_lock lock;
// 初始化锁
self.lock = OS_SPINLOCK_INIT;
// 加锁
os_unfair_lock_lock(&_lock);
加锁 和 解锁 中间放 多个线程访问的资源
// 解锁
os_unfair_lock_unlock(&_lock);

3、pthread_mutex:(互斥锁)：

3.1、等待锁的线程会处于休眠状态
3.2、需要导入头文件 #import <pthread.h>
3.3、Mutex type attributes 有如下四种类型

#define PTHREAD_MUTEX_NORMAL 0 普通锁
#define PTHREAD_MUTEX_ERRORCHECK 1  检查错误的锁
#define PTHREAD_MUTEX_RECURSIVE 2 递归锁
#define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL 普通锁

3.4、有普通互斥锁，递归锁、有条件的互斥锁三种

4、NSLock:(互斥锁)：对mutex普通锁的封装
使用如下

// 定义锁的属性
@property(nonatomic,strong) NSLock *lock;
// 初始化锁
self. lock = [[NSLock alloc]init];
// 加锁
[self.lock lock];
 加锁 和 解锁 中间放 多个线程访问的资源
// 解锁
[self.lock unlock];

5、NSRecursiveLock:也是对mutex递归锁的封装，API跟NSLock基本一致
使用如下

// 定义锁的属性
@property(nonatomic,strong) NSRecursiveLock *lock;
// 初始化锁
self. lock = [[NSRecursiveLock alloc]init];
// 加锁
[self.lock lock];
 加锁 和 解锁 中间放 多个线程访问的资源
// 解锁
[self.lock unlock];

6、NSCondition(带有条件的互斥锁):是对mutex和cond的封装
使用如下

// 定义锁和条件的属性
@property(nonatomic,strong) NSCondition *conditLock;
// 初始化锁和条件
self. conditLock = [[NSCondition alloc]init];
// 加锁
[self. conditLock lock];
// 等待(等待的条件和唤醒的条件 cond 必须保持一致)
[self.conditLock wait];
加锁 和 解锁 中间放 多个线程访问的资源
// 唤醒等待
[self.conditLock signal];
// 广播 (唤醒所有等待的条件 cond 必须保持一致)
// [self.conditLock broadcast];  
// 解锁
[self. conditLock unlock];

7、NSConditionLock(带有条件的互斥锁):是对NSCondition的进一步封装，可以设置具体的条件值
使用如下：

// 定义锁和条件的属性
@property(nonatomic,strong) NSConditionLock *conditLock;
// 初始化锁和条件(initWithCondition:跟的是条件)
self.conditLock = [[NSConditionLock alloc]initWithCondition:1];
// 不写条件的话默 条件 为 0
// self.conditLock = [[NSConditionLock alloc]init]; 
// 加锁(根据条件是否相同进行加锁)
[self.conditLock lockWhenCondition:1];
 加锁 和 解锁 中间放 多个线程访问的资源
// 解锁(解锁的条件随便写：如果解锁后要执行其他的线程，可以设置和其他的线程匹配的条件)
[self.conditLock unlockWithCondition:2];

8、dispatch_queue (DISPATCH_QUEUE_SERIAL:串行)：
直接使用GCD的串行队列，也是可以实现线程同步的（只要能够保证在同一时间不共享一块资源就可以

使用如下：

// 创建全局队列
@property(nonatomic,strong) dispatch_queue_t ticketLock;
// 初始化队列(名字设置：ticketLock)
self.ticketLock = dispatch_queue_create("ticketLock", DISPATCH_QUEUE_SERIAL);
dispatch_sync(self.ticketLock, ^{
    // 共享资源的代码
});

9、dispatch_semaphore信号量

9.1、信号量的初始值，可以用来控制线程并发访问的最大数量
9.2、信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步
使用如下：

// 定义信号量变量
@property (strong, nonatomic) dispatch_semaphore_t semaphore;

// 初始化信号量变量
self. semaphore = dispatch_semaphore_create(1);

// 如果信号量的值 > 0，就让信号量的值减1，然后继续往下执行代码
// 如果信号量的值 <= 0，就会休眠等待，直到信号量的值变成>0，就让信号量的值减1，然后继续往下执行代码
dispatch_semaphore_wait(self. semaphore, DISPATCH_TIME_FOREVER);

 多个线程访问的资源
dispatch_semaphore_signal(self. semaphore);

10、@synchronized(mutex递归锁的封装)

10.1、@synchronized是对mutex递归锁的封装
10.2、源码查看：objc4中的objc-sync.mm文件
10.3、@synchronized(obj)内部会生成obj对应的递归锁，然后进行加锁、解锁操作

@synchronized(obj){
        任务
}

三、多线程同步方案性能比较

1、性能从高到低排序

os_unfair_lock ：从iOS10开始才支持(互斥锁)
OSSpinLock ：在iOS10 被os_unfair_lock取代
dispatch_semaphore
pthread_mutex
dispatch_queue(DISPATCH_QUEUE_SERIAL)
NSLock
NSCondition
pthread_mutex(recursive)
NSRecursiveLock
NSConditionLock
@synchronized

2、自旋锁、互斥锁比较

2.1、什么情况使用自旋锁(占用CPU)比较划算？
- 预计线程等待锁的时间很短
- 加锁的代码（临界区）经常被调用，但竞争情况很少发生
- CPU资源不紧张
- 多核处理器
2.2、什么情况使用互斥锁比较划算？
- 预计线程等待锁的时间较长
- 单核处理器
- 临界区有IO操作（文件的读写操作）
- 临界区代码复杂或者循环量大
- 临界区竞争非常激烈

四、iOS中的读写安全方案

1、读写安全目标：

1.1、同一时间，只能有1个线程进行写的操作
1.2、同一时间，允许有多个线程进行读的操作
1.3、同一时间，不允许既有写的操作，又有读的操作

2、读写安全方案：

2.1、pthread_rwlock：读写锁
2.2、dispatch_barrier_async：异步栅栏调用

3、pthread_rwlock：读写锁(互斥锁)
使用方法如下：

#import "Pthread_rwlock.h"
#import <pthread.h>

@interface Pthread_rwlock ()
property (assign, nonatomic) pthread_rwlock_t lock;
@end

@implementation Pthread_rwlock

- (instancetype)init{
    if (self = [super init]) {
        [self createFunction];
    }
    return self;
}

-(void)createFunction{
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    pthread_rwlock_init(&_lock, NULL);
    for (int i = 0; i<10; i++) {
        dispatch_async(queue, ^{
            [self read];
        });
        dispatch_async(queue, ^{
            [self write];
        });   
    }
}

// 读文件
-(void)read{
    // 读可以多条线程进行
    pthread_rwlock_rdlock(&_lock);
    sleep(1.0);
    NSLog(@"--读--");
    pthread_rwlock_unlock(&_lock);
}

// 写文件
-(void)write{
    // 在写的时候没有读的操作 且 写只能有一条线程进行
    pthread_rwlock_wrlock(&_lock);
    sleep(1.0);
    NSLog(@"--写--");
    pthread_rwlock_unlock(&_lock);  
}
@end

4、pthread_rwlock：读写锁(互斥锁)

这个函数传入的并发队列必须是自己通过dispatch_queue_cretate创建的
如果传入的是一个串行或是一个全局的并发队列，那这个函数便等同于dispatch_async函数的效果

   self.queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
    for (int i = 0; i<10; i++) {
        dispatch_async(self.queue, ^{
            [self read];
        });
        dispatch_async(self.queue, ^{
            [self write];
        });
    }

一、定时器（CADisplayLink、NSTimer、GCD）

1、CADisplayLink、NSTimer

如果target对CADisplayLink、NSTimer进行引用，那么就会引发循环引用，如下办法解决：

1、使用NSTimer 的block方法
   __weak typeof(self) weakSelf = self;

2、通过中间对象(代理对象)的方式来解决

ZMJProxy *proxy = [ZMJProxy  proxyWithTarget:vc];
ZMJProxy1 *proxy1 = [ZMJProxy1 proxyWithTarget:vc];
//判断是否是这个类或者这个类的子类的实例 
NSLog(@"%d %d",[proxy isKindOfClass:[ViewController class]],[proxy1 isKindOfClass:[ViewController class]]);
继承NSProxy会进行消息转发 ， 通过target调用方法

2、定时器（GCD）

比较准时，它直接和系统内核挂钩的(NSTimer依赖于RunLoop，如果RunLoop的任务过于繁重，可能会导致NSTimer不准时

  //创建队列
    //    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_queue_t queue = dispatch_queue_create("timer", DISPATCH_QUEUE_SERIAL);
  
    /*
     创建定时器
     1、 intervalInSeconds 时间值 多少秒后开始执行
     2、 leewayInSeconds   时间间隔 多长时间开始执行
     */
    dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
    dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, 2.0 * NSEC_PER_SEC, 1.0 * NSEC_PER_SEC);
    //第一种方法：
    //    dispatch_source_set_event_handler(timer, ^{
    //        NSLog(@"111111111");
    //    });
    
    //第二种方法：
    dispatch_source_set_event_handler_f(timer, timerFire);
    dispatch_resume(timer);
    
    self.timer = timer;

IOS01-多线程底层
多线程是为了执行多个任务而生的，之前写过一些基础的东西，现在记录一下更为高级的用法，方便来复习一、多线程基础知识...
iOS面试题--网络多线程
一、多线程的底层实现？ 1>线程：Mach是第一个以多线程方式处理任务的系统，因此多线程的底层实现机制是基于Mac...
底层-多线程
iOS中的常见多线程方案 GCD的常用函数 GCD中有2个用来执行任务的函数用同步的方式执行任务dispatch...
iOS----GCD
Grand Central Dispatch（多线程的优化技术）GCD 是一套底层API，基于C语言开发的多线程...
iOS 多线程: NSThread的介绍
NSThread的封装性在多线程中是最差的, 最偏向于底层, 主要基于thread使用一: 多线程的概念: 线程...
Java入门系列09 -- 多线程，I/O
进程，线程，多线程的相关概念这里就不做阐述，可参考 iOS底层系列22 -- 多线程基础概念[https://ww...
iOS面试题锦集（一）——多线程网络
1. 多线程的底层实现？首先搞清楚什么是线程、什么是多线程； Mach（国际发音：[mʌk]）是第一个以多线程方...
iOS 多线程
一、多线程的底层实现？提示：1> 首先搞清楚什么是线程、什么是多线程2>Mach是第一个以多线程方式处理任务的系...
多线程网络
1.多线程的底层实现 1> 首先搞清楚什么是线程，什么是多线程说起多线程，那么就不得不说什么是线程，而说起线程，...
01-关于多线程&网络
1.多线程的底层实现？ 1>首先搞清楚什么是线程、什么是多线程 2> Mach是第一个以多线程方式处理任务的系统，...