iOS 中的锁

在iOS 开发的过程当中,线程的是最长用到的.在使用线程的时候,多线程的安全性也被暴露了出来.
下面先看一下代码

__block NSInteger total = 0;
    for (NSInteger index = 0; index < 3; index++) {
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            total += 1;
            NSLog(@"total_1: %ld",total);
            total -= 1;
            NSLog(@"total_2: %ld",total);
        });
    }

在看一下打印出来的结果

第一次输出:
2018-07-08 15:33:56.976347+0800 zifu[2047:2740812] total_1: 3
2018-07-08 15:33:56.976445+0800 zifu[2047:2740812] total_2: 2
2018-07-08 15:33:56.975873+0800 zifu[2047:2740807] total_1: 1
2018-07-08 15:33:56.976541+0800 zifu[2047:2740807] total_2: 1
2018-07-08 15:33:56.976048+0800 zifu[2047:2740806] total_1: 2
2018-07-08 15:33:56.976603+0800 zifu[2047:2740806] total_2: 0


第二次输出
2018-07-08 15:34:44.401901+0800 zifu[2049:2741231] total_1: 1
2018-07-08 15:34:44.402012+0800 zifu[2049:2741231] total_2: 1
2018-07-08 15:34:44.401903+0800 zifu[2049:2741228] total_1: 2
2018-07-08 15:34:44.402059+0800 zifu[2049:2741231] total_1: 2
2018-07-08 15:34:44.402068+0800 zifu[2049:2741228] total_2: 1
2018-07-08 15:34:44.402088+0800 zifu[2049:2741231] total_2: 0

通过这两次结果的打印可以发现,在每次运行结束后打印的结果就会不同.这样的线程是不安全的.

那么如果在线程当中加了把"锁"呢!

    __block NSInteger totoal = 0;
    NSLock *lock = [[NSLock alloc] init];
    for (NSInteger index = 0; index < 3; index++) {
        [lock lock];
        totoal += 1;
        NSLog(@"totoal_1: %ld",totoal);
        totoal -= 1;
        NSLog(@"totoal_2: %ld",totoal);
        [lock unlock];
    }

第一次打印结果

2018-07-08 15:38:33.322351+0800 zifu[2052:2742390] totoal_1: 1
2018-07-08 15:38:33.322457+0800 zifu[2052:2742390] totoal_2: 0
2018-07-08 15:38:33.322489+0800 zifu[2052:2742390] totoal_1: 1
2018-07-08 15:38:33.322515+0800 zifu[2052:2742390] totoal_2: 0
2018-07-08 15:38:33.322540+0800 zifu[2052:2742390] totoal_1: 1
2018-07-08 15:38:33.322565+0800 zifu[2052:2742390] totoal_2: 0

第二次打印结果

2018-07-08 15:39:09.998407+0800 zifu[2054:2742784] totoal_1: 1
2018-07-08 15:39:09.998503+0800 zifu[2054:2742784] totoal_2: 0
2018-07-08 15:39:09.998535+0800 zifu[2054:2742784] totoal_1: 1
2018-07-08 15:39:09.998561+0800 zifu[2054:2742784] totoal_2: 0
2018-07-08 15:39:09.998587+0800 zifu[2054:2742784] totoal_1: 1
2018-07-08 15:39:09.998611+0800 zifu[2054:2742784] totoal_2: 0

经过多次运行,每次打印出来的结果都是一样的.这样的线程简单来说就是安全的.
原因嘛,加了把锁造成的.

在说锁之前先了解一下多线程的基本概念

• 进程 : 可以理解成一个运行中的应用程序,是系统进行资源分配和调度的基本单位,是操作系统结构的基础,主要管理资源.
• 线程 : 是进程中的基本单元,一个进程对应多个线程.
• 主线程 : 处理UI,所有更新UI的操作都必须在主线程上执行.不要把消耗操作放在主线程,会卡界面.
• 多线程 : 在同一时刻,一个CPU只能处理1条线程,但CPU可以在多条线程之间快速的切换,只要切换的速度足够快,就造成了多线程一同执行的假象.
• 线程就像火车的一节车厢,进程则是火车.车厢离开火车是无法跑动的,而火车至少要有一节车厢(主线程).多线程可以看做多个车厢,它的出现是为了提高效率.
• 多线程是通过提高资源使用率来提高系统总体的效率.
• 目的 将耗时操作放在后台去执行.

那么这种线程的不安全性要怎么解决呢!
1.既然线程安全问题是由多线程引起的,那么,最极端的可以使用单线程保证线程安全.
2.线程安全是由于多线程访问和修改共享资源而引起不可预测的结果,因此,如果都是访问共享资源而不去修改资源也可以保证线程安全,比如:设置只读属性的全局变量
3.使用锁:
pthread_mutex:
pthread_mutex表示互斥锁,和信号量的实现原理类似,也是阻塞线程并进入睡眠,需要进行上下文切换.

pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_NORMAL);
pthread_mutex_t lock;
pthread_mutex_init(&lock, &attr);//设置属性
pthread_mutex_lock (&lock);//上锁

//代码

pthread_mutex_unlock(&lock);//解锁

NSLock:
NSLock在内部疯转了一个pthread_mutex,属性为PTHREAD_MUTEX_ERRORCHECK;

NSLock *lock = [NSLock new];
[lock lock];
//代码
[lock unlock];

NSCondition:
NSCondition封装了一个互斥锁和条件变量.互斥锁保证线程安全,条件变量保证执行顺序.

NSCondition *lock = [NSCondition new];
[lock lock];
//执行代码
[lock unlock];

pthread_mutext(recursive):
pthread_mutex 锁的一种,属于递归锁.一般一个线程只能申请一把锁,但是,如果是递归锁,则可以真情很多把锁,只要上锁和解锁的操作数量就不会报错:

pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
     
pthread_mutex_t lock;
pthread_mutex_init(&lock, &attr);    //设置属性
     
pthread_mutex_lock(&lock);    //上锁
//需要执行的代码
pthread_mutex_unlock(&lock);    //解锁

NSRecursiceLock
递归锁,pthread_mutex(recursive)的封装.

NSRecursiveLock *lock = [NSRecursiveLock new];
[lock lock];
//需要执行的代码
[lock unlock];

NSConditionLock
NSConditionLock借助 NSCondition 来实现，本质是生产者-消费者模型。

NSConditionLock *lock = [NSConditionLock new];
[lock lock];
//需要执行的代码
[lock unlock];

参考:iOS的线程安全和锁