iOS的多线程安全隐患与线程同步方案

// 初始化锁的属性
 pthread_mutexattr_t attr;
 pthread_mutexattr_init(&attr);
 /**
 * @param attr:参数
 * @param type:锁的类型，传NULL也是默认
 */
 pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_NORMAL);
 //锁的类型
 #define PTHREAD_MUTEX_NORMAL 0 // 普通锁
 #define PTHREAD_MUTEX_ERRORCHECK 1 // 检测错误的锁
 #define PTHREAD_MUTEX_RECURSIVE 2  // 递归锁
 #define PTHREAD_MUTEX_DEFAULT PTHREAD_MUTEX_NORMAL
 // 初始化锁
 pthread_mutex_t mutex;
 pthread_mutex_init(&mutex,&attr);
 // 尝试加锁
 pthread_mutex_trylock(&mutex);
 // 加锁
 pthread_mutex_lock(&mutex);
 // 解锁
 pthread_mutex_unlock(&mutex);
 // 销毁相关资源
 pthread_mutexattr_destroy(&attr);
 pthread_mutex_destroy(&mutex);

// 初始化属性
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    // NULL代表默认属性
    pthread_mutexattr_settype(&attr, NULL);
    // 初始化锁
    pthread_mutex_t mutex;
    pthread_mutex_init(&mutex, &attr);
    // 销毁属性
    pthread_mutexattr_destroy(&attr);
    // 初始化条件
    pthread_cond_t cond;
    pthread_cond_init(&cond, NULL);
    // 等待条件（进入休眠，放开mutex锁；被唤醒后，会再次对mutex加锁）
    pthread_cond_wait(&cond, &mutex);
    // 激活一个等待该条件的线程
    pthread_cond_signal(&cond);
    // 激活所有等待该条件的线程
    pthread_cond_boradcast(&cond);
    // 销毁相关资源
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond);

// 初始化这把锁带有的属性
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    // 设置这把锁属性的类型：
    // PTHREAD_MUTEX_RECURSIVE递归锁，允许同一个线程对同一把锁进行重复加锁
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
    // 初始化锁
    pthread_mutex_t mutex;
    pthread_mutex_init(mutex, &attr);
    // 销毁属性
    pthread_mutexattr_destroy(&attr);
    // 销毁锁
    pthread_mutex_destroy(&mutex);

@interface Demo()
@property (strong, nonatomic) NSConditionLock *conditionLock;
@end
@implementation Demo
- (instancetype)init {
    if (self = [super init]) {
        self.conditionLock = [[NSConditionLock alloc] initWithCondition:1];
    }
    return self;
}
- (void)test {
  // 1、当首个加锁触发没有添加条件时，那么在初始化的时候，不管设置什么条件，都能正常执行
    [self.conditionLock lock];
    // 2、如果有加条件，那么必须跟设置的条件匹配
    // [self.conditionLock lockWhenCondition:1];
    NSLog(@"test");
    sleep(1);
    [self.conditionLock unlockWithCondition:2];
}
@end

// 信号量初始值
    int value = 5;
    // 初始化信号量
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(value);
    /**
     * 1、如果信号量的值 > 0，就让信号量的值减1，然后继续往下执行代码
     * 2、如果信号量的值 <= 0，就会休眠等待，直到信号量的值变成 > 0，就让信号量的值减1，然后继续往下执行代码
     */
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    // 让信号量的值加1
    dispatch_semaphore_signal(semaphore);

@interface Demo()
@property (strong, nonatomic) dispatch_queue_t myQueue;
@end
@implementation Demo
- (instancetype)init {
    if (self = [super init]) {
        self.myQueue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_SERIAL);
    }
    return self;
}
- (void)test1 {
    dispatch_sync(self.myQueue, ^{
        NSLog(@"%s",__func__);
    });
}
- (void)test2 {
    dispatch_sync(self.myQueue, ^{
        NSLog(@"%s",__func__);
    });
}
@end

// 初始化锁
    pthread_rwlock_t lock;
    pthread_rwlock_init(&lock, NULL);
    // 读 - 加锁
    pthread_rwlock_rdlock(&lock);
    // 读 - 尝试加锁
    pthread_rwlock_tryrdlock(&lock);
    // 写 - 加锁
    pthread_rwlock_wrlock(&lock);
    // 写 - 尝试加锁
    pthread_rwlock_trywrlock(&lock);
    // 解锁
    pthread_rwlock_unlock(&lock);
    // 毁锁
    pthread_rwlock_destroy(&lock);

#import "ViewController.h"
#import <pthread.h>
@interface ViewController ()
@property (strong, nonatomic) dispatch_queue_t queue;
@end
@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
    /**
    * 1、必须是自己通过dispatch_queue_cretate创建的
    * 2、如果传入的是串行或全局的并发队列，那这个函数便等同于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 read];
        });
        dispatch_async(self.queue, ^{
            [self read];
        });
        dispatch_barrier_async(self.queue, ^{
            [self write];
        });
    }
}
- (void)read {
    sleep(1);
    NSLog(@"read");
}
- (void)write {
    sleep(1);
    NSLog(@"write");
}
@end