#import "ViewController.h"
#import <libkern/OSAtomic.h>// OSSpinLock頭文件
#import <os/lock.h>// os_unfair_lock頭文件
#import <pthread.h>// pthread_mutex_t頭文件
#import <pthread.h>// pthread_rwlock_t頭文件

@interface ViewController ()

@property (nonatomic, strong) UIView *bgView;

@property (nonatomic) int count;

/// 自旋鎖-忙等
@property (nonatomic, assign) OSSpinLock ossLock;

/// NSLock-對pthread_mutex_t的封裝
@property (nonatomic, strong) NSLock *lock;

/// 隊列組
@property (nonatomic, strong) dispatch_group_t grounp;

/// os_unfair_lock-互斥鎖
@property (nonatomic, assign) os_unfair_lock osUnLock;

/// 互斥鎖（遞歸鎖：允許同一個線程對一把鎖進行加鎖；不同線程需要等待）-需要銷毀
@property (nonatomic, assign) pthread_mutex_t mutex;
@property (nonatomic, assign) pthread_cond_t cond;

/// 遞歸鎖-對pthread_mutex_t的封裝
@property (nonatomic, strong) NSRecursiveLock *reLock;

/// 條件鎖-對mutex和cond的封裝
@property (nonatomic, strong) NSCondition *condition;

/// 條件鎖-對NSCondition的封裝（設(shè)置線程依賴）
@property (nonatomic, strong) NSConditionLock *condLock;

/// 讀寫鎖-需要銷毀
@property (nonatomic, assign) pthread_rwlock_t rwLock;

/// 柵欄dispatch_barrier_async

@end

@implementation ViewController

- (void)dealloc {
    /// 銷毀鎖
    pthread_mutex_destroy(&_mutex);
    
    /// 銷毀條件
    pthread_cond_destroy(&_cond);
    
    /// 銷毀讀寫鎖
    pthread_rwlock_destroy(&_rwLock);
}

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view.
    
    _bgView = [[UIView alloc] init];
    _bgView.frame = CGRectMake(0, 0, 100, 100);
    _bgView.backgroundColor = UIColor.redColor;
    [self.view addSubview:_bgView];
    
    self.ossLock = OS_SPINLOCK_INIT;
    
    self.lock = [[NSLock alloc] init];
    
    self.grounp = dispatch_group_create();
    
    self.osUnLock = OS_UNFAIR_LOCK_INIT;
    
    /// 初始化屬性
    pthread_mutexattr_t attr;
    pthread_mutexattr_init(&attr);
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_DEFAULT);
    //pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);/// 遞歸鎖
    /// 初始化鎖
    pthread_mutex_init(&_mutex, &attr);
    /// 銷毀屬性
    pthread_mutexattr_destroy(&attr);
    
    /*
     /// 添加條件鎖（不同線程執(zhí)行任務(wù)時需要的控制條件，線程依賴川慌，使用場景：可變數(shù)組刪除和添加元素）
     pthread_cond_init(&_cond, NULL);
     /// ??以下兩個方法需要放在加鎖解鎖中間執(zhí)行
     /// 根據(jù)條件，進入休眠狀態(tài)钳枕，放開當(dāng)前鎖缴渊；被喚醒后會再次對當(dāng)前線程加鎖
     pthread_cond_wait(&_cond, &_mutex);
     /// 處理完成赏壹，發(fā)送信號喚醒鎖
     pthread_cond_signal(&_cond);
     /// 處理完成，廣播通知等待該條件的所有線程衔沼，喚醒鎖蝌借，和pthread_cond_signal二選一
     pthread_cond_broadcast(&_cond);
     /// ??
     */
    
    self.reLock = [[NSRecursiveLock alloc] init];
    
    self.condition = [[NSCondition alloc] init];
    
    self.condLock = [[NSConditionLock alloc] initWithCondition:1];
    
    pthread_rwlock_init(&_rwLock, NULL);
    
    /*
     /// 讀鎖
     pthread_rwlock_rdlock(&_rwLock);
     /// 寫鎖
     pthread_rwlock_wrlock(&_rwLock);
     /// 讀寫鎖解鎖
     pthread_rwlock_unlock(&_rwLock);
     */
    
    self.count = 15;
    
    [self test];
    
}

- (void)test {
    
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i ++) {
            [self doSomething];
        }
    });

    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i ++) {
            [self doSomething];
        }
    });

    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i ++) {
            [self doSomething];
        }
    });
    
//    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
//
//    dispatch_group_async(self.grounp, queue, ^{
//        for (int i = 0; i < 5; i ++) {
//            [self doSomething];
//        }
//    });
//
//    dispatch_group_async(self.grounp, queue, ^{
//        for (int i = 0; i < 5; i ++) {
//            [self doSomething];
//        }
//    });
//
//    dispatch_group_async(self.grounp, queue, ^{
//        for (int i = 0; i < 5; i ++) {
//            [self doSomething];
//        }
//    });
    
}

- (void)doSomething {
    
//    OSSpinLockLock(&_ossLock);
    
//    [self.lock lock];
    
//    dispatch_group_enter(self.grounp);
    
//    os_unfair_lock_lock(&_osUnLock);
    
//    pthread_mutex_lock(&_mutex);
    
//    [self.reLock lock];
    
//    [self.condition lock];
////    [self.condition wait];
    
    [self.condLock lockWhenCondition:self.condLock.condition];
    
    self.count --;
    NSLog(@"當(dāng)前線程：%@ 操作剩余 = %d", [NSThread currentThread], self.count);
    
    [self.condLock unlockWithCondition:self.condLock.condition];
    
////    [self.condition signal];
////    [self.condition broadcast];
//    [self.condition unlock];
    
//    [self.reLock unlock];
    
//    pthread_mutex_unlock(&_mutex);
    
//    os_unfair_lock_unlock(&_osUnLock);
    
//    dispatch_group_leave(self.grounp);
    
//    [self.lock unlock];
    
//    OSSpinLockUnlock(&_ossLock);
    
}

@end