OC底层知识(十一) : 多线程

作者: IIronMan | 来源:发表于2018-10-25 22:49 被阅读166次

一、简介：多线程在之前进行过一篇详细的基础博客 iOS多线程

二、多线程的基础知识回顾

1.1、iOS中的常见多线程方案

技术方案	简介	语言	线程生命周期	使用频率
`pthread`	一套通用的多线程API;适用于`Unix\Linux\Windows`等系统;跨平台\可移植;使用难度大	C语言	程序员管理	几乎不用
`NSThread`	使用更加面向对象；简单易用，可直接操作线程对象	OC	程序员管理	偶尔使用
`GCD`	旨在替代NSThread等线程技术；充分利用设备的多核	C	自动管理	经常使用
`NSOperation`	基于GCD（底层是GCD）；比GCD多了一些更简单实用的功能；使用更加面向对象	OC	自动管理	经常使用

1.2、GCD中有2个用来执行任务的函数(queue：队列 block：任务)
- 用同步的方式执行任务
```
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
```
- 用异步的方式执行任务
```
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
```
- GCD源码
1.3、GCD的队列可以分为2大类型
- 并发队列（Concurrent Dispatch Queue）
  - 可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
  - 并发功能只有在异步（dispatch_async）函数下才有效
- 串行队列（Serial Dispatch Queue）
  - 让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）
1.4、有4个术语比较容易混淆：同步、异步、并发、串行
- 同步(dispatch_sync)和异步(dispatch_async)主要影响：能不能开启新的线程
  - 同步：在当前线程中执行任务，不具备开启新线程的能力
  - 异步：在新的线程中执行任务，具备开启新线程的能力
- 并发和串行主要影响：任务的执行方式
  - 并发：多个任务并发（同时）执行
  - 串行：一个任务执行完毕后，再执行下一个任务

1.5、各种队列的执行效果

各种队列的执行效果
注意:使用sync函数往当前串行队列中添加任务，会卡住当前的串行队列。如下：

#pragma mark 看下面的代码是否会产生死锁：会
// 队列的特点：排队，FIFO，First In First Out，先进先出
-(void)interview1{

     NSLog(@"---------1-------");

     dispatch_queue_t queue = dispatch_get_main_queue();
     dispatch_sync(queue, ^{
 
           NSLog(@"---------2-------");
     });
     // dispatch_sync: 立马在当前线程执行任务，执行完毕才能继续往下执行
     NSLog(@"---------3-------");

}

总结：只要不存在谁等谁的情况就不会有线程的阻塞

1.6、看下面的打印结果

-(void)interview6{

  dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
  dispatch_async(queue, ^{

     NSLog(@"1");
     
     // 这句代码的本质是往Runloop中添加定时器
     [self performSelector:@selector(test) withObject:nil afterDelay:.0];
     /**
          没有添加定时器（test可以立马执行）
          [self performSelector:@selector(test) withObject:nil];
      */ 

     NSLog(@"3");
  });   
}

-(void)test{
   NSLog(@"2");
}

打印结果是：1、3
原因：

performSelector:withObject:afterDelay:这句代码的本质是往Runloop中添加定时器
子线程默认没有启动Runloop
可以添加下面的代码来启动RunLoop
[[NSRunLoop currentRunLoop]addPort:[[NSPort alloc]init] forMode:NSDefaultRunLoopMode];
[[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];

1.7、GNUstep 是GNU计划的项目之一，它将Cocoa的OC库重新开源实现了一遍

三、多线程 GCD 队列组：notify(唤醒)

 // 创建队列组
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 < 5; i++) {
        NSLog(@"任务2-%@", [NSThread currentThread]);
    }
});

下面使用唤醒代码（和上面的代码是连着的）

3.1、唤醒后在主线程执行任务

// 等前面的任务执行完毕后，会自动执行这个任务
dispatch_group_notify(group, queue, ^{
   // async 异步，dispatch_get_main_queue() 主线程
   dispatch_async(dispatch_get_main_queue(), ^{
        for (int i = 0; i < 5; i++) {
             NSLog(@"任务3-%@", [NSThread currentThread]);
        }
   });
});

3.2、唤醒后在主线程执行任务

dispatch_group_notify(group, dispatch_get_main_queue(), ^{
    for (int i = 0; i < 5; i++) {
       NSLog(@"任务3-%@", [NSThread currentThread]);
    }
});

3.3、唤醒后再执行另外两个子线程任务

dispatch_group_notify(group, queue, ^{
    for (int i = 0; i < 5; i++) {
        NSLog(@"任务3-%@", [NSThread currentThread]);
    }
});

dispatch_group_notify(group, queue, ^{
    for (int i = 0; i < 5; i++) {
      NSLog(@"任务4-%@", [NSThread currentThread]);
    }
});

四、多线程安全隐患: 常见的是 `买票` 与 `存钱取钱`

4.1、多线程安全隐患在什么情况下会出现
- 资源共享
  - 1块资源可能会被多个线程共享，也就是多个线程可能会访问同一块资源
  - 比如多个线程访问同一个对象、同一个变量、同一个文件
- 当多个线程访问同一块资源时，很容易引发数据错乱和数据安全问题

4.2、安全隐患的展示：(买票)

安全隐患的展示：(买票)

/**
   票的数量
 */
@property(nonatomic,assign) int ticketCount;

-(void)ticketTest{
    // 放出 20张票
    self.ticketCount = 20;

    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_async(queue, ^{
 
    for (int i = 0; i<10; i++) {
     
          [self buyTicket];
    }
});

  dispatch_async(queue, ^{
 
     for (int i = 0; i<10; i++) {
     
          [self buyTicket];
     }
   });
}
// 线程调用买票
-(void)buyTicket{

   int oldTickCount = self.ticketCount;
   sleep(0.2);
   oldTickCount --;
   self.ticketCount = oldTickCount;

   NSLog(@"还有%d张票-%@",oldTickCount,[NSThread currentThread]);
}

调用ticketTest 看下面的打印结果(数据错乱)

调用ticketTest 看下面的打印结果

4.3、安全隐患的展示：(存钱与取钱)

安全隐患的展示：(存钱与取钱)

/**
   钱的数量
 */
@property(nonatomic,assign) int moneyCount;

#pragma mark 9.取钱存钱的测试(多线程安全的隐患)
-(void)moneyTest{

   self.moneyCount = 100;

   dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
   dispatch_async(queue, ^{
 
       for (int i = 0; i<10; i++) {
     
          // 存钱
          [self saveMoney];
       }
    });

   dispatch_async(queue, ^{
 
       for (int i = 0; i<10; i++) {
     
           // 取钱
           [self drawMoney];
       }
   });
}

// 存钱
-(void)saveMoney{

   int oldMoney = self.moneyCount;
   sleep(0.2);
   oldMoney = oldMoney + 50;
   self.moneyCount = oldMoney;

   NSLog(@"存进去50元，余额是%d - %@",oldMoney,[NSThread currentThread]);
}

// 取钱
-(void)drawMoney{

    int oldMoney = self.moneyCount;
    sleep(0.2);
    oldMoney = oldMoney - 20;
    self.moneyCount = oldMoney;

    NSLog(@"花去20元，余额是%d - %@",oldMoney,[NSThread currentThread]);
}

调用moneyTest 看下面的打印结果(数据错乱)

4.4、多线程安全隐患分析图
- 由下图也可以看出同一块资源在同一个时间段有多个线程访问，这样能够造成资源混乱
  多线程安全隐患分析图
4.5、多线程安全隐患的解决方案
- 解决方案：使用线程同步技术（同步，就是协同步调，按预定的先后次序进行）
- 常见的线程同步技术是：加锁
- 由下图也可以看出同一块资源在同一个时间段只能由一个线程访问

多线程安全隐患的解决方案(枷锁)

五、iOS中的线程同步方案（下面锁的调用都在 ThreadLockViewController里面，锁的封装在JKBaseCode）：锁使用的demo

5.1、目前我所知道的有如下 10 种

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
5.2、OSSpinLock (自旋锁)Height-level lock 多线程的demo:OSSpinLockDemo与OSSpinLockDemo2里面有对买票和存钱取钱的 自旋锁 使用
- OSSpinLock叫做”自旋锁”，等待锁的线程会处于忙等（busy-wait）状态，一直占用着CPU资源(相当于while循环阻塞线程)
- 'OSSpinLock' is deprecated: first deprecated in iOS 10.0 - Use os_unfair_lock() from <os/lock.h> instead(在iOS10 被os_unfair_lock取代)
- 目前已经不再安全，可能会出现优先级反转问题
  - 如果等待锁的线程优先级较高，它会一直占用着CPU资源，优先级低的线程就无法释放锁
    
    OSSpinLock (自旋锁)
- OSSpinLock 使用如下：（具体的可以看demo）
```
导入头文件#import <libkern/OSAtomic.h>

定义锁   
@property(nonatomic,assign) OSSpinLock lock;
// 初始化锁
self.lock = OS_SPINLOCK_INIT;

// 加锁
OSSpinLockLock(&_lock);

加锁 和 解锁 中间放 多个线程访问的资源

// 解锁
OSSpinLockUnlock(&_lock);
```
- 分析：OSSpinLock 不再安全是因为会出现优先级反转问题，当有多条线程的时候，优先级比较高的线程会优先占用lock(锁)，优先级相对较低的线程就无法加锁，只有等优先级高的线程先执行完才可以进行加锁和解锁。
5.3、os_unfair_lock (互斥锁)Low-level lock
- os_unfair_lock用于取代不安全的OSSpinLock ，从iOS10开始才支持
  - 从底层调用看，等待os_unfair_lock锁的线程会处于休眠状态，并非忙等
  - 需要导入头文件 #import <os/lock.h>
    os_unfair_lock：互斥锁
- os_unfair_lock 使用如下：（具体的可以看demo）
```
导入头文件 #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);
```
5.4、pthread_mutex:(互斥锁)Low-level lock
- mutex：英[m'ju:teks] 叫做“互斥锁”，等待锁的线程会处于休眠状态
- 需要导入头文件 #import <pthread.h>
- 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 普通锁
    pthread_mutex
- 具体的使用(不懂的看demo)
```
// 静态初始化
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

// 初始化属性
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
// 初始化锁
pthread_mutex_init(mutex, &attr);
// 销毁属性
pthread_mutexattr_destroy(&attr);

// 加锁
pthread_mutex_lock(&mutex);

加锁 和 解锁 中间放 多个线程访问的资源

// 解锁
pthread_mutex_unlock(&_ticketMutex);

// 销毁相关资源
- (void)dealloc
{
   pthread_mutex_destroy(&_ticketMutex);
   pthread_mutex_destroy(&_moneyMutexk);
}
```
- 有关 递归锁 的使用请看demo里面的 Pthread_mutexLockDemo2
  
  pthread_mutex – 递归锁
- 带有条件的互斥锁 pthread_mutex_t,看demo里面的 Pthread_mutexLockDemo3 (应用场景是：一条线程的执行需要等待另外一条线程先执行，可以加等待条件condition)
  
  pthread_mutex – 条件

5.5、NSLock:(互斥锁)：对mutex普通锁的封装

NSLock:(**互斥锁**)

使用如下：

// 定义锁的属性
@property(nonatomic,strong) NSLock *lock;

// 初始化锁
self. lock = [[NSLock alloc]init];

// 加锁
[self.lock lock];

 加锁 和 解锁 中间放 多个线程访问的资源

// 解锁
[self.lock unlock];

5.6、NSRecursiveLock:也是对mutex递归锁的封装，API跟NSLock基本一致

NSRecursiveLock

使用如下：

// 定义锁的属性
@property(nonatomic,strong) NSRecursiveLock *lock;

// 初始化锁
self. lock = [[NSRecursiveLock alloc]init];

// 加锁
[self.lock lock];

 加锁 和 解锁 中间放 多个线程访问的资源

// 解锁
[self.lock unlock];

5.7、NSCondition(带有条件的互斥锁):是对mutex和cond的封装

NSCondition(带有条件的互斥锁)

使用如下：

// 定义锁和条件的属性
@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];

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

NSConditionLock

使用如下：(适用环境：根据条件设置线程的执行顺序，比如两个网络请求，第2个依赖于第一个的结果，那就就可以设置条件)

// 定义锁和条件的属性
@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];

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

使用如下：(具体的代码看demo里面的Dispatch_queueDemo)

// 创建全局队列
@property(nonatomic,strong) dispatch_queue_t ticketLock;

// 初始化队列(名字设置：ticketLock)
self.ticketLock = dispatch_queue_create("ticketLock", DISPATCH_QUEUE_SERIAL);

dispatch_sync(self.ticketLock, ^{
    // 共享资源的代码
});

5.10、dispatch_semaphore (也是最大并发数：只要设置为 1 就可以只执行一件事)

semaphore叫做"信号量"
信号量的初始值，可以用来控制线程并发访问的最大数量
信号量的初始值为1，代表同时只允许1条线程访问资源，保证线程同步

semaphore 信号量

使用如下：

// 定义信号量变量
@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);

5.11、@synchronized(mutex递归锁的封装)
- @synchronized是对mutex递归锁的封装
- 源码查看：objc4中的objc-sync.mm文件
- @synchronized(obj)内部会生成obj对应的递归锁，然后进行加锁、解锁操作
  
  @synchronized是对mutex递归锁的封装
5.12、iOS 线程同步方案性能比较(推荐使用下面的第3和第4)

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

六、iOS中的读写安全方案

6.1、思考如何实现以下场景
- 同一时间，只能有1个线程进行写的操作
- 同一时间，允许有多个线程进行读的操作
- 同一时间，不允许既有写的操作，又有读的操作
6.2、上面的场景就是典型的“多读单写”，经常用于文件等数据的读写操作，iOS中的实现方案有
- pthread_rwlock：读写锁
- dispatch_barrier_async：异步栅栏调用

6.3、pthread_rwlock：读写锁(互斥锁)
等待锁的线程会进入休眠

pthread_rwlock读写锁(**互斥锁**)

具体的代码：（具体的可以看demo里面的Pthread_rwlockViewController控制器里面的代码）
读可以多条线程进行

在写的时候没有读的操作且写只能有一条线程进行

#import "Pthread_rwlockViewController.h"
#import <pthread.h>
@interface Pthread_rwlockViewController ()

property (assign, nonatomic) pthread_rwlock_t lock;

@end

@implementation Pthread_rwlockViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    self.view.backgroundColor = [UIColor whiteColor];

    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

6.4、dispatch_barrier_async
- 这个函数传入的并发队列必须是自己通过dispatch_queue_cretate创建的
- 如果传入的是一个串行或是一个全局的并发队列，那这个函数便等同于dispatch_async函数的效果
  
  dispatch_barrier_async
- 具体的代码看demo里面Dispatch_barrier_asyncViewController控制器
6.5、这是上面所有代码的demo

OC底层知识(十一) : 多线程

一、简介：多线程在之前进行过一篇详细的基础博客 iOS多线程

二、多线程的基础知识回顾

三、多线程 GCD 队列组：notify(唤醒)

四、多线程安全隐患: 常见的是 `买票` 与 `存钱取钱`

五、iOS中的线程同步方案（下面锁的调用都在 ThreadLockViewController里面，锁的封装在JKBaseCode）：锁使用的demo

六、iOS中的读写安全方案

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

iOS 开发每天分享优质文章

OC底层知识(十一) : 多线程

一、简介：多线程在之前进行过一篇详细的基础博客 iOS多线程

二、多线程的基础知识回顾

三、多线程 GCD 队列组：notify(唤醒)

四、多线程安全隐患: 常见的是 买票 与 存钱取钱

五、iOS中的线程同步方案（下面锁的调用都在 ThreadLockViewController里面，锁的封装在JKBaseCode）：锁使用的demo

六、iOS中的读写安全方案

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

iOS 开发每天分享优质文章

四、多线程安全隐患: 常见的是 `买票` 与 `存钱取钱`