iOS中的多线程

// _mutex成员变量已在前方初始化
- (void)test1 {
    // 这里需要加锁
    pthread_mutex_lock(&_mutex);
    // 执行test2方法
    [self test2];
    // 解锁
    pthread_mutex_unlock(&_mutex);
}
- (void)test2 {
    // 这里需要加锁
    pthread_mutex_lock(&_mutex);
    // 执行其他代码
    dosomething...
    // 解锁
    pthread_mutex_unlock(&_mutex);
}

// 属性
@property (assign, nonatomic) pthread_mutex_t mutex; // 锁
@property (assign, nonatomic) pthread_cond_t cond; // 条件
@property (strong, nonatomic) NSMutableArray *data; // 操作的数据

// 方法
- (instancetype)init
{
    if (self = [super init]) {
        // 初始化属性
        pthread_mutexattr_t attr;
        pthread_mutexattr_init(&attr);
        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);

        // 初始化锁
        pthread_mutex_init(&_mutex, &attr);

        // 销毁属性
        pthread_mutexattr_destroy(&attr);
        
        // 初始化条件
        pthread_cond_init(&_cond, NULL);
        
        self.data = [NSMutableArray array];
    }
    return self;
}
- (void)otherTest
{
    // 线程1 remove
    [[[NSThread alloc] initWithTarget:self selector:@selector(__remove) object:nil] start];

    // 线程2 add
    [[[NSThread alloc] initWithTarget:self selector:@selector(__add) object:nil] start];
}

// 生产者-消费者模式
// 线程1 删除数组中的元素
- (void)__remove
{
    pthread_mutex_lock(&_mutex);  // 加锁

    NSLog(@"__remove - begin");
    
    if (self.data.count == 0) {
        // 等待条件，本质上线程相当于睡觉了，睡觉的同时也把锁放开了；
        // 可以理解为线程卡在这一行代码了，等他其他线程将条件放开后，会继续加锁
        pthread_cond_wait(&_cond, &_mutex); 
    }
    
    [self.data removeLastObject];
    NSLog(@"删除了元素");
    
    pthread_mutex_unlock(&_mutex);
}

// 线程2 往数组中添加元素
- (void)__add
{
    pthread_mutex_lock(&_mutex);
    
    sleep(1);
    
    [self.data addObject:@"Test"];
    NSLog(@"添加了元素");
    
    // 通过发送信号方式通知条件,激活另外一个等待该条件的线程。
    // 另外一个等待该条件的线程要想执行任务，需等待该线程把锁放开(unlock)
    pthread_cond_signal(&_cond);

    // 也可通过广播方式，激活所有等待该条件的线程
    // pthread_cond_broadcast(&_cond);
    pthread_mutex_unlock(&_mutex);
}

NSLock *lock = [NSLock alloc] init];
// 加锁
[lock lock];
// 解锁
[lock unlock];
// 传入一个时间，在等待(线程休眠)这个时间之前，如果能等待这把锁放开，就给这把锁加锁返回YES，否则返回NO(没有加锁)
[lock BeforeDate:[NSDate distantFuture]];

@interface NSConditionDemo()
@property (strong, nonatomic) NSCondition *condition;
@property (strong, nonatomic) NSMutableArray *data;
@end

@implementation NSConditionDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.condition = [[NSCondition alloc] init];
        self.data = [NSMutableArray array];
    }
    return self;
}

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

// 生产者-消费者模式

// 线程1
// 删除数组中的元素
- (void)__remove
{
    [self.condition lock];
    NSLog(@"__remove - begin");
    
    if (self.data.count == 0) {
        // 等待
        [self.condition wait];
    }
    
    [self.data removeLastObject];
    NSLog(@"删除了元素");
    [self.condition unlock];
}

// 线程2
// 往数组中添加元素
- (void)__add
{
    [self.condition lock];
    
    sleep(1);
    
    [self.data addObject:@"Test"];
    NSLog(@"添加了元素");
    
    // 信号
    [self.condition signal];
    
    sleep(2);
    
    [self.condition unlock];
}

@interface NSConditionLockDemo()
@property (strong, nonatomic) NSConditionLock *conditionLock;
@end

@implementation NSConditionLockDemo

- (instancetype)init
{
    if (self = [super init]) {
        self.conditionLock = [[NSConditionLock alloc] initWithCondition:1];
    }
    return self;
}

- (void)otherTest
{
    // 三个线程同时启动
    NSLog(@"程序启动");
    [[[NSThread alloc] initWithTarget:self selector:@selector(__two) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__one) object:nil] start];
    
    [[[NSThread alloc] initWithTarget:self selector:@selector(__three) object:nil] start];
}

- (void)__one
{
    // 如果先进入__two方法或者__three，条件锁会休眠等待__one方法先执行
    [self.conditionLock lock];
    
    NSLog(@"__one");
    sleep(1);

    // 解锁，把锁放开给条件2
    [self.conditionLock unlockWithCondition:2];
}

- (void)__two
{
    [self.conditionLock lockWhenCondition:2];
    
    NSLog(@"__two");
    sleep(4);

    // 解锁，把锁放开给条件3
    [self.conditionLock unlockWithCondition:3];
}

- (void)__three
{
    // lockWhenCondition:beforeDate:
    // 在等待(线程休眠)这个beforeDate时间之前，如果能等待这把锁放开，就给这把锁加锁返回YES，否则返回NO(没有加锁)，执行后面代码

    // 可判断返回值(加锁成功或失败)，执行不同操作
    BOOL result = [self.conditionLock lockWhenCondition:3 beforeDate:[NSDate dateWithTimeIntervalSinceNow:2]];
    
    NSLog(@"__three");
    [self.conditionLock unlock];
}

@property (strong, nonatomic) dispatch_queue_t queue1;
self.queue1 = dispatch_queue_create("queue1", DISPATCH_QUEUE_SERIAL);
dispatch_sync(self.moneyQueue, ^{
    // 需注意dosomething需要保证在当前线程内执行

    dosomething...
});

@property (strong, nonatomic) dispatch_semaphore_t semaphore;

- (instancetype)init
{
    if (self = [super init]) {
        // 设置最大并发数量
        self.semaphore = dispatch_semaphore_create(5);
        [self test];
    }
    return self;
}
- (void)test
{
    // 如果信号量的值 > 0，就让信号量的值减1，然后继续往下执行代码
    // 如果信号量的值 <= 0，就会休眠等待，直到信号量的值变成>0，就让信号量的值减1，然后继续往下执行代码
    dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
    
    sleep(2);
    NSLog(@"test - %@", [NSThread currentThread]);
    
    // 让信号量的值+1
    dispatch_semaphore_signal(self.semaphore);
}

// obj是个锁对象，在线程同步操作时，需保证obj是同一个锁对象
@synchoronized(obj) {
    // 执行任务
}

#import <pthread.h>

@interface ViewController ()
@property (strong, nonatomic) dispatch_queue_t queue;
@end

@implementation ViewController

// dispatch_barrier_async一般叫做“栅栏函数”，它就好像栅栏一样可以将多个操作分隔开，在它前面追加的操作先执行，在它后面追加的操作后执行
- (void)viewDidLoad {
    [super viewDidLoad];
    
    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];
        });
        
        // 在它前面的函数先执行，也就会打印3次read，最后再打印write
        dispatch_barrier_async(self.queue, ^{
            [self write];
        });
        // 输出：先3次read，最后1次write
    }
}

- (void)read {
    sleep(1);
    NSLog(@"read");
}

- (void)write
{
    sleep(1);
    NSLog(@"write");
}

@end

#import <pthread.h>

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

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    // 初始化锁
    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];
        });
    }
}


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

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

- (void)dealloc
{
    pthread_rwlock_destroy(&_lock);
}

@end