/**
 *设置属性值
 */
-(void)setMyTestString:(NSString *)myTestString{
    @synchronized(self) {
        // todo something
        _myTestString = myTestString;
    }
}

//注意：此时为了保证单例模式的更加严谨，需要重写`allocWithZone`方法，保证其他开发者使用`alloc`和`init`方法时，不再创建新的对象。必要的时候还需要重写`copyWithZone`方法防止`copy`属性对单例模式的影响。 iOS中还有一种更加轻便的方法实现单例模式，即使用GCD中的dispatch_once函数实现。

+(instancetype)shareInstance{
    // 1.定义一个静态实例，初值nil
    static TestSynchronized *myClass = nil;
    // 2.添加同步锁，创建实例
    @synchronized(self) {
        // 3.判断实例是否创建过，创建过则退出同步锁，直接返回该实例
        if (!myClass) {
            // 4.未创建过，则新建一个实例并返回
            myClass = [[self alloc] init];
        }
    }
    return myClass;
}

///定义一个静态锁变量, lock--unlock 、tryLuck---unLock  必须成对存在
static NSLock *mylock;
-(void)viewDidLoad {
    [super viewDidLoad];
    mylock = [[NSLock alloc] init];
}

//当前线程锁失败，也可以继续其它任务，用 trylock 合适
-(void)myLockTest1{
    if ([mylock tryLock]) {
        // to do something
        [mylock unlock];
    }
}

//当前线程只有锁成功后，才会做一些有意义的工作，那就lock，没必要轮询trylock
-(void)myLockTest2{
    [mylock lock];
    // to do something
    [mylock unlock];
}

//创建递归锁
NSRecursiveLock *myRecursiveLock = [[NSRecursiveLock alloc] init];
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        static void (^MyRecursiveLockBlock)(int value);
        MyRecursiveLockBlk = ^(int value){
            [myRecursiveLock lock];
            if (value > 0) {
                // to do something
                NSLog(@"MyRecursiveLockBlk value = %d", value);
                MyRecursiveLockBlock(value - 1);
            }
            [myRecursiveLock unlock];
        };
        MyRecursiveLockBlock(6);
});

//注意：此时如果将例程中的递归锁换成互斥锁：
//NSRecursiveLock *myRecursiveLock = [[NSRecursiveLock alloc] init];换成
//NSLock *myLock = [[NSLock alloc] init];，则会发生死锁问题。

#import "ViewController.h"
#import <pthread.h>
@interface ViewController ()
@property(nonatomic, copy) NSString *rwStr;
@end

@implementation ViewController

///全局的读写锁
pthread_rwlock_t rwlock;

-(void)viewDidLoad {
    [super viewDidLoad];
    // 初始化读写锁
    pthread_rwlock_init(&rwlock,NULL);
    __block int i;
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        i = 5;
        while (i>=0) {
            NSString *temp = [NSString stringWithFormat:@"writing == %d", i];
            [self writingLock:temp];
            i--;
        }  
    });
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        i = 5;
        while (i>=0) {
            [self readingLock];
            i--;
        }
    });
}
// 写加锁
-(void)writingLock:(NSString *)temp{
    pthread_rwlock_wrlock(&rwlock);
    // writing
    self.rwStr = temp;
    NSLog(@"%@", temp);
    pthread_rwlock_unlock(&rwlock);
}
// 读加锁
-(NSString *)readingLock{
    pthread_rwlock_rdlock(&rwlock);
    // reading
    NSString *str = self.rwStr;
    NSLog(@"reading == %@",self.rwStr);
    pthread_rwlock_unlock(&rwlock);
    return str;
}
@end

// 头文件
#import <libkern/OSAtomic.h>
// 初始化自旋锁
static OSSpinLock myLock = OS_SPINLOCK_INIT;
// 自旋锁的使用
-(void)SpinLockTest{
    OSSpinLockLock(&myLock);
    // to do something
    OSSpinLockUnlock(&myLock);
}

//给文件创建分布锁
NSDistributedLock *lock = [[NSDistributedLock alloc] initWithPath:@"/Users/mac/Desktop/lock.lock"];
while (![lock tryLock])
{
    sleep(1);
}

//do something

[lock unlock];

//但在实际使用过程中,当执行到do something时程序退出,程序再次启动之后tryLock就再也不能成功了,陷入死锁状态.这是使用NSDistributedLock时非常隐蔽的风险.其//实要解决的问题就是如何在进程退出时会自动释放锁.

//创建信号
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

[self getTasksWithCompletionHandler:^ {

    //doing something

    //持有信号
     dispatch_semaphore_signal(semaphore);
}];

//释放信号
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

- (id)objectForKey:(NSString *)key {
    
     __block id obj;
     //同步读取指定数据  
     dispatch_sync(concurrent_queue, ^{
          obj = [userCenterDic objectForKey:key];      
     });

     return obj;
}    


-(void)setObject:(id )obj foeKey:(NSString *)key{
      
     //异步栅栏调用设置数据
     dispatch_async(concurrent_queue, ^{
           [userCenterDic setObject:obj forKey:key];      
     });
}

//创建锁
__block pthread_mutex_t theLock;
pthread_mutex_init(&theLock, NULL);

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
     pthread_mutex_lock(&theLock);
     NSLog(@"需要线程同步的操作1 开始");
     sleep(3);
     NSLog(@"需要线程同步的操作1 结束");
     pthread_mutex_unlock(&theLock);     
});
    
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
      sleep(1);
      pthread_mutex_lock(&theLock);
      NSLog(@"需要线程同步的操作2");
      pthread_mutex_unlock(&theLock);   
});

//注意：这是pthread_mutex为了防止在递归的情况下出现死锁而出现的递归锁。作用和NSRecursiveLock递归锁类似。
//如果使用pthread_mutex_init(&theLock, NULL)初始化锁的话，下面的代码会出现死锁现象，但是改成使用递归锁的形式，则没有问题。

//创建锁 
__block pthread_mutex_t theLock;
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE); //设置成递归类型
pthread_mutex_init(&lock, &attr);
pthread_mutexattr_destroy(&attr);
    
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{   
    static void (^RecursiveMethod)(int);
    RecursiveMethod = ^(int value) {
        pthread_mutex_lock(&theLock);
        if (value > 0) {
            NSLog(@"value = %d", value);
            sleep(1);
            RecursiveMethod(value - 1);
        }
        pthread_mutex_unlock(&theLock);
   };
   RecursiveMethod(5);
});