聊一聊多线程

2021-02-18 本文已影响0人晨阳Xia

多线程分类

image.png

c语言的关键字是assign
修饰结构体的关键字assign

死锁的原因

// 死锁
- (void)viewDidLoad {
    [super viewDidLoad];
    NSLog(@"任务1");
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_sync(queue, ^{
        NSLog(@"任务2");
    });
    NSLog(@"任务3");

};
// 不会死锁
- (void)viewDidLoad {
    [super viewDidLoad];
    NSLog(@"任务1");
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_async(queue, ^{
        NSLog(@"任务2"); // 任务2不会等待上一个任务的完成出栈
    });
    NSLog(@"任务3");

};

image.png

死锁总结

使用sync函数往当前串行队列中添加任务,会卡住当前的串行队列，产生死锁。

锁

OSSpinLock（自旋锁）

OSSpinLock“自旋锁”，等待锁的线程会处于忙等（busy-wait）状态，一只占用着CPU资源
自旋锁不休眠

#import <libkern/OSAtomic.h>

// 定义锁 c语言的关键字是assign
@property (assign, nonatomic) OSSpinLock moneyLock;

// 初始化
self.moneyLock = OS_SPINLOCK_INIT;

OSSpinLockLock(&_moneyLock);
...加锁的任务
OSSpinLockUnlock(&_moneyLock);

什么时候使用自旋锁

预计线程等待锁的时间很短
加锁的代码（临界区）经常被调用，但竞争情况很少发生
CPU资源不紧张的时候

os_unfair_lock（互斥锁）

os_unfair_lock 用于取代不安全的OSSpinLock,从iOS10开始才支持
从底层调用看，等待os_fair_lock锁的线程会处于休眠状态，并非忙等
加锁没解锁会导致死锁
互斥锁会休眠

#import <os/lock.h>

// 定义锁 c语言的关键字是assign
@property (assign, nonatomic) os_unfair_lock moneyLock;

// 初始化
self.moneyLock = OS_UNFAIR_LOCK_INIT;

os_unfair_lock_lock(&_moneyLock);
...加锁的任务  
os_unfair_lock_unlock(&_moneyLock);

什么时候用互斥锁

预计线程等待锁的时间比较长
单核处理器
加锁的代码（临界区）有IO操作
加锁的代码（临界区）代码复杂或者循环量大
加锁的代码（临界区）竞争非常激烈

pthread_mutex(跨平台的锁)

mutex:互斥锁，等待锁的线程会处于休眠状态
可以实现递归锁
递归锁：允许同一个线程对一把锁进行重复加锁。
递归锁解决了：同一线程下，同一把普通锁的死锁问题

#define PTHREAD_MUTEX_NORMAL        0
#define PTHREAD_MUTEX_ERRORCHECK    1
#define PTHREAD_MUTEX_RECURSIVE     2
#define PTHREAD_MUTEX_DEFAULT       PTHREAD_MUTEX_NORMAL

#import <pthread.h>
// 定义锁 c语言的关键字是assign
@property (assign, nonatomic) pthread_mutex_t moneyLock;

// 初始化
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(&_moneyLock);
...加锁的任务  
pthread_mutex_unlock(&_moneyLock);

添加依赖条件的 pthread_cond_t

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

@interface XSYPhreadCondLock ()

@property (assign, nonatomic) pthread_mutex_t mutex;
@property (assign, nonatomic) pthread_cond_t cond;
@property (strong, nonatomic) NSMutableArray *data;

@end

@implementation XSYPhreadCondLock

- (instancetype)init {
    self = [super init];
    if (self) {
        pthread_mutexattr_t attr;
        pthread_mutexattr_init(&attr);
        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
        
        pthread_mutex_init(&_mutex, &attr);
        
        pthread_cond_init(&_cond, NULL);
        
        self.data= [[NSMutableArray alloc] init];
    }
    return self;
}

- (void)otherTest {
    [[[NSThread alloc] initWithTarget:self selector:@selector(__remove) object:nil] start];
    [[[NSThread alloc] initWithTarget:self selector:@selector(__add) object:nil] start];
}


- (void)__remove {
    pthread_mutex_lock(&_mutex);
    if (self.data.count == 0) {
        pthread_cond_wait(&_cond, &_mutex);
    }
    [self.data removeObjectAtIndex:0];
    NSLog(@"删除了一个元素");
    pthread_mutex_unlock(&_mutex);
}

- (void)__add {
    pthread_mutex_lock(&_mutex);
    [self.data addObject:@"test"];
    NSLog(@"添加了一个元素");
    pthread_mutex_unlock(&_mutex);
    pthread_cond_signal(&_cond);
}

- (void)dealloc {
    pthread_mutex_destroy(&_mutex);
}

@end

NSLock (自旋锁)

nslock是对pthread_mutex普通锁的封装，本质是一个NSObject对象


@property (strong, nonatomic) NSLock *moneyLock;

self.moneyLock = [[NSLock alloc] init];

[self.moneyLock lock];
...加锁的任务  
[self.moneyLock unlock];

NSCursiveLock （递归锁）

NSCursiveLock是对pthread_mutex递归锁的封装

NSCondition

NSCondition是对pthread_mutex递归锁带有cond条件的封装

NSConditionLock

NSConditionLock 是对NSCodition的进一步封装。达到了顺序执行子线程的内容的效果。

@property (strong, nonatomic) NSConditionLock *moneyLock;

self.moneyLock = [[NSConditionLock alloc] initWithCondition:0];

- (void)__drawMoney {
    [self.moneyLock lockWhenCondition:1]; // condition为1的时候才会加锁
    ...加锁的任务
    [self.moneyLock unlockWithCondition:0]; // 解锁并将condition置为0
}

- (void)__saveMoney {
    [self.moneyLock lockWhenCondition:0]; // condition为0的时候才会加锁
    ...加锁的任务
    [self.moneyLock unlockWithCondition:1]; // 解锁并将condition置为1
}

@synchronized

synchronized是对mutex的封装

- (void)__sellTicket {
    static NSObject *lock;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        lock = [[NSObject alloc] init];
    });
    @synchronized (lock) {
        ... 加锁的内容
    };
}
或
@synchronized ([self class]) {
    ...加锁的内容
};

信号量 dispatch_semaphore_t

@property (strong, nonatomic) dispatch_semaphore_t semaphore;

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

- (void)__saveMoney {
    dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
    ... 执行的内容
    dispatch_semaphore_signal(self.semaphore);
}

线程同步的本质

线程同步的本质是：不要让多条线程同时占用一份资源

线程同步的实现方式

1、串行队列
2、锁
3、信号量

锁性能对比

image.png

atomic

atomic使用的是自旋锁加锁
atomic耗内存
保证set、get方法内部线程安全，但无法保证操作安全。

@property (strong, atomic) NSMutableArray *data;

self.data = [[NSMutableArray alloc] init]; // `set方法`是线程安全
[self.data addObject:@"1"]; // self.data线程安全，但是`添加操作`不是线程安全的
[self.data addObject:@"2"];
[self.data addObject:@"3"];

所以声明属性一般使用nonatomic。

实现多读单写

pthread_rwlock (自旋锁)

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

@interface XSYPthreadrwlock ()

@property (assign, nonatomic) pthread_rwlock_t lock;

@end

@implementation XSYPthreadrwlock

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

- (void)read {
    pthread_rwlock_rdlock(&_lock);
    NSLog(@"%s", __func__);
    pthread_rwlock_unlock(&_lock);
}

- (void)write {
    pthread_rwlock_wrlock(&_lock);
    NSLog(@"%s",__func__);
    pthread_rwlock_unlock(&_lock);
}

@end

dispatch_barrier_async

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

#import "XSYDispatchBarrier.h"

@interface XSYDispatchBarrier ()

@property (strong, nonatomic) dispatch_queue_t queue;

@end

@implementation XSYDispatchBarrier

- (instancetype)init {
    self = [super init];
    if (self) {
        self.queue = dispatch_queue_create("barrier", DISPATCH_QUEUE_CONCURRENT);
        
        for (int i = 0; i < 10; i++) {
            [self read];
            
            [self write];
        }
    }
    return self;
}

- (void)read {
    
    dispatch_async(_queue, ^{
        NSLog(@"%@",@"read");
    });
}

- (void)write {
    
    dispatch_barrier_async(_queue, ^{
        
        NSLog(@"%@",@"write");
    });
}

@end

聊一聊多线程

多线程分类

死锁的原因

死锁总结

锁

OSSpinLock（自旋锁）

什么时候使用自旋锁

os_unfair_lock（互斥锁）

什么时候用互斥锁

pthread_mutex(跨平台的锁)

NSLock (自旋锁)

NSCursiveLock （递归锁）

NSCondition

NSConditionLock

@synchronized

信号量 dispatch_semaphore_t

线程同步的本质

线程同步的实现方式

锁性能对比

atomic

实现多读单写

pthread_rwlock (自旋锁)

dispatch_barrier_async

猜你喜欢

热点阅读