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

dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

#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-------");
}

-(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");
}

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

// 创建队列组
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]);
    }
});

// 等前面的任务执行完毕后，会自动执行这个任务
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]);
        }
   });
});

dispatch_group_notify(group, dispatch_get_main_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(@"任务3-%@", [NSThread currentThread]);
    }
});
dispatch_group_notify(group, queue, ^{
    for (int i = 0; i < 5; i++) {
      NSLog(@"任务4-%@", [NSThread currentThread]);
    }
});

/**
   票的数量
 */
@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]);
}

/**
   钱的数量
 */
@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]);
}

导入头文件#import <libkern/OSAtomic.h>
定义锁   
@property(nonatomic,assign) OSSpinLock lock;
// 初始化锁
self.lock = OS_SPINLOCK_INIT;
// 加锁
OSSpinLockLock(&_lock);
加锁 和 解锁 中间放 多个线程访问的资源
// 解锁
OSSpinLockUnlock(&_lock);

导入头文件 #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);

// 静态初始化
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);
}

// 定义锁的属性
@property(nonatomic,strong) NSLock *lock;
// 初始化锁
self. lock = [[NSLock alloc]init];
// 加锁
[self.lock lock];
 加锁 和 解锁 中间放 多个线程访问的资源
// 解锁
[self.lock unlock];

// 定义锁的属性
@property(nonatomic,strong) NSRecursiveLock *lock;
// 初始化锁
self. lock = [[NSRecursiveLock alloc]init];
// 加锁
[self.lock lock];
 加锁 和 解锁 中间放 多个线程访问的资源
// 解锁
[self.lock unlock];

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

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

// 创建全局队列
@property(nonatomic,strong) dispatch_queue_t ticketLock;
// 初始化队列(名字设置：ticketLock)
self.ticketLock = dispatch_queue_create("ticketLock", DISPATCH_QUEUE_SERIAL);
dispatch_sync(self.ticketLock, ^{
    // 共享资源的代码
});

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

#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