美文网首页
聊一聊多线程

聊一聊多线程

作者: 晨阳Xia | 来源:发表于2021-02-18 14:18 被阅读0次

    多线程分类

    image.png 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

    相关文章

      网友评论

          本文标题：聊一聊多线程

          本文链接：https://www.haomeiwen.com/subject/rragxltx.html

          延伸阅读

          深度阅读

          • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

          栏目导航

          热点阅读

          关于我们|服务条款|联系我们|聊一聊多线程|投稿指南|网站地图|RSS订阅|排版工具|手机版

          提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

          Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

          备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

          本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

          所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！