iOS中的锁（5）

本文主要介绍pthread和读写锁，以及自定义一个简单的读写锁。

1. pthread

1.1 TLS

安全传输层协议(TLS)用于在两个通信应用程序之间提供保密性和数据完整性。

该协议由两层组成:
TLS 记录协议(TLS Record)和 TLS 握手协议(TLS Handshake)。

传输层安全性协议（Transport Layer Security），缩写为TLS，及其前身安全套接字（Secure Sockets Layer，缩写作SSL）是一种安全协议，目的是为互联网通信提供安全及数据完整性保障。网景公司（Netscape）在1994年推出首版网页浏览器，网景导航者时，推出HTTP协议，以SSL进行加密，这是SSL的起源。IETF将SSL进行标准化，1999年公布第一版TLS标准文件，随后又公布了RFC5246（2008年8月）与RFC6176（2011年3月）。在浏览器、邮箱、即时通讯、VoIP、网络传值等应用程序中，广泛支持这个协议。主要的网站，如Google、Facebook等也以这个协议来创建安全连线，发送数据。目前已成为互联网上保密同学的工业标准。

SSL包含记录层（Record Layer）和传输层，记录层协议确定传输层数据的封装格式。传输层安全协议使用X.509认证，之后利用非对称加密演算来对通信方做身份认证，之后交换对称密钥作为会谈密钥（Session Key）。这会谈密钥是用来将通信两方交换的数据做加密，保证两个应用间通信的保密性和可靠性，是客户与服务器应用之间的通信不被攻击者窃听。

1.2 TLS 线程相关解释

线程局部存储(Thread Local Storage,TLS): 是操作系统为线
程单独提供的私有空间，通常只有有限的容量。Linux系统下
通常通过pthread库中的 pthread_key_create()、pthread_getspecific()、 pthread_setspecific()、 pthread_key_delete()。

1.3 互斥锁

在Posix Thread中定义有一套专⻔用于线程同步的mutex函数。mutex用于保证在任何时刻，都只能有一个线程访问该对象。 当获取锁操作失败时，线程会进入睡眠，等待锁释放时被唤醒。

1. 创建和销毁
   1. POSIX定义了一个宏PTHREAD_MUTEX_INITIALIZER来静态初始化互斥锁
   2. 初始化：int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr)
   3. 注销：pthread_mutex_destroy()
2. 互斥锁属性
   1. 互斥锁，分为递归锁和非递归锁。
   2. 对于递归锁使用的是PTHREAD_MUTEX_RECURSIVE
3. 锁操作
   1. 加锁：int pthread_mutex_lock(pthread_mutex_t *mutex)
   2. 解锁：int pthread_mutex_unlock(pthread_mutex_t *mutex)
   3. 尝试加锁：int pthread_mutex_trylock(pthread_mutex_t *mutex)，在锁被占用是返回EBUSY，不会挂起线程等待。

2. 读写锁

读写锁实际是一种特殊的自旋锁，它把对共享资源的访问者划分成读者和写者，读者只对共享资源 进行读访问，写者则需要对共享资源进行写操作。这种锁相对于自旋锁而言，能提高并发性，因为在多处理器系统中，它允许同时有多个读者来访问共享资源，最大可能的读者数为实际的逻辑CPU数。写者是排他性的，一个读写锁同时只能有一个写者或多个读者(与CPU数相关)，但不能同时既有读者又有写者。在读写锁保持期间也是抢占失效的。

如果读写锁当前没有读者，也没有写者，那么写者可以立刻获得读写锁，否则它必须自旋在那里，直到没有任何写者或读者。

如果读写锁没有写者，那么读者可以立即获得该读写锁，否则读者必须自旋在那里，直到写者释放该读写锁。

一次只有一个线程可以占有写模式的读写锁，但是可以有多个线程同时占有读模式的读写锁。正是因为这个特性，当读写锁是写加锁状态时，在这个锁被解锁之前，所有试图对这个锁加锁的线程都会被阻塞。当读写锁在读加锁状态时，所有试图以读模式对它进行加锁的线程都可以得到访问权，但是如果线程希望以写模式对此锁进行加锁，它必须直到所有的线程释放锁。通常当读写锁处于读模式锁住状态时，如果有另外线程试图以写模式加锁，读写锁通常会阻塞随后的读模式锁请求，这样可以避免读模式锁⻓期占用，而等待的写模式锁请求⻓期阻塞。读写锁适合于对数据结构的读次数比写次数多得多的情况。因为，读模式锁定时可以共享，以写模式锁住时意味着独占, 所以读写锁又叫共享-独占锁。

2.1 iOS中的的读写锁

读写锁适合于对数据结构的读次数比写次数多得多的情况。因为，读模式锁定时可以共享，以写模式锁住时意味着独占，所以读写锁又叫共享-独占锁。

2.1.1 初始化读写锁

#include <pthread.h>
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock)

• 初始化成功则返回0, 出错则返回错误编号。
• 同互斥量以上，在释放读写锁占用的内存之前，需要先通过pthread_rwlock_destroy对读写锁进行清理工作，释放由init分配的资源。

2.1.2 读写锁操作

1. 读锁：int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
2. 写锁：int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
3. 解锁：int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

• 成功则返回0，出错则返回错误编号。
• 对于读锁和写锁是会阻塞线程的

1. 尝试读锁：int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
2. 尝试写锁：int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

• 成功则返回0，出错则返回错误编号。
• 非阻塞的获取锁操作，如果可以获取则返回0，否则返回错误的EBUSY。

2.2 自定义读写锁

2.2.1 自定义读写锁代码

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface MYRWLock : NSObject
// 读数据
- (id)my_objectForKey:(NSString *)key;
// 写数据
- (void)my_setObject:(id)obj forKey:(NSString *)key;
@end

NS_ASSUME_NONNULL_END


#import "MYRWLock.h"

@interface MYRWLock ()
// 定义一个并发队列:
@property (nonatomic, strong) dispatch_queue_t concurrent_queue;
// 用户数据中心, 可能多个线程需要数据访问:
@property (nonatomic, strong) NSMutableDictionary *dataCenterDic;
@end

@implementation MYRWLock

- (id)init{
    self = [super init];
    if (self){
        // 创建一个并发队列:
        self.concurrent_queue = dispatch_queue_create("com.my.read_write_queue", DISPATCH_QUEUE_CONCURRENT);
        // 创建数据字典:
        self.dataCenterDic = [NSMutableDictionary dictionary];
    }
    return self;
}

#pragma mark - 读数据
- (id)my_objectForKey:(NSString *)key{
    __block id obj;
    // 同步读取指定数据:
    dispatch_sync(self.concurrent_queue, ^{
        obj = [self.dataCenterDic objectForKey:key];
    });
    return obj;
}

#pragma mark - 写数据
- (void)my_setObject:(id)obj forKey:(NSString *)key{
    // 异步栅栏调用设置数据:
    dispatch_barrier_async(self.concurrent_queue, ^{
        [self.dataCenterDic setObject:obj forKey:key];
    });
}

@end

这里在写操作的时候，使用栅栏函数进行阻塞，读的时候不做限制。

2.2.2 使用示例

@property (nonatomic, strong) MYRWLock *rwLock;

- (void)testRWLock {
    self.rwLock = [[MYRWLock alloc] init];
    
    dispatch_queue_t queue = dispatch_queue_create("com.test.rwlock", DISPATCH_QUEUE_CONCURRENT);
    
    for (int i = 0; i<10; i++) {
        dispatch_async(queue, ^{
            NSString *str = [NSString stringWithFormat:@"rw_test%d",i];
            NSLog(@"写%@---%@",str, [NSThread currentThread]);
            [self.rwLock my_setObject:str forKey:@"rwKey"];
        });
    }
    
    for (int i = 0; i<10; i++) {
        dispatch_async(queue, ^{
            NSLog(@"读 %@---%@",[self.rwLock my_objectForKey:@"rwKey"], [NSThread currentThread]);
        });
    }
}