iOS底层原理 - 探寻多线程本质（四）

面试题引发的思考：

Q: 修饰词atomic和nonatomic修饰属性的区别？

• atomic用于保证属性setter、getter的原子性操作
  (相当于在getter和setter内部加了线程同步的锁 - 自旋锁)；
• atomic不能保证使用属性的过程是线程安全的。

Q: “多读单写”实现方案？

• pthread_rwlock：读写锁
• dispatch_barrier_async：异步栅栏调用

// 初始化队列
dispatch_queue_t queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
// 读
dispatch_async(queue, ^{

});
// 写
dispatch_barrier_async(queue, ^{

});

---

1. 解析atomic原理

• atomic用于保证属性setter、getter的原子性操作
  (相当于在getter和setter内部加了线程同步的锁-自旋锁)；
• atomic不能保证使用属性的过程是线程安全的。

@interface Person : NSObject
@property (nonatomic, assign) int age;
@property (atomic, copy) NSString *name;
@end

@implementation Person
// nonatomic修饰属性
- (void)setAge:(int)age {
    _age = age;
}
- (int)age {
    return _age;
}
// atomic修饰属性
// 保证属性的setter和getter都是原子性操作，也就是保证setter和gette内部是线程同步的
- (void)setName:(NSString *)name {
    // 加锁
    name = name;
    // 解锁
}
- (NSString *)name {
    // 加锁
    return _name;
    // 解锁
}
@end

查找OC源码中的objc-accessors.mm文件：

objc_setProperty方法

由objc_setProperty方法源码可知：

• 如果属性修饰词为atomic，则setter方法中会先添加自旋锁，再赋值，最后解锁；
• 否则直接赋值即可。

objc_getProperty方法

由objc_getProperty方法源码可知：

• 如果属性修饰词为atomic，则getter方法中会先添加自旋锁，再取值，最后解锁并返回取值；
• 否则直接取值并返回取值即可。

可以通过以下代码分析使用atomic修饰属性的影响：

// TODO: ----------------- Person类 -----------------
@interface Person : NSObject
@property (atomic, strong) NSMutableArray *dataArray;
@end

@implementation Person
@end

// TODO: ----------------- main -----------------
int main(int argc, const char * argv[]) {
    @autoreleasepool {
        // insert code here...
        Person *person = [[Person alloc] init];

        person.dataArray = [NSMutableArray array];
        [person.dataArray addObject:@"1"]; // 线程安全
        [person.dataArray addObject:@"2"];  // 非线程安全

        // 以上三行代码相当于以下代码：
        [person setDataArray:[NSMutableArray array]]; // 线程安全
        NSMutableArray *array = [person dataArray]; // 线程安全
        [array addObject:@"1"];  // 非线程安全
        [array addObject:@"2"];  // 非线程安全
    }
    return 0;
}

---

2. iOS中的读写安全方案

Q: 思考如何实现以下场景？

• 同一时间，只能有1个线程进行写的操作；
• 同一时间，允许有多个线程进行读的操作；
• 同一时间，不允许既有写的操作，又有读的操作。

上面的场景就是典型的“多读单写”，经常用于文件等数据的读写操作。

“多读单写”实现方案有：

• pthread_rwlock：读写锁
• dispatch_barrier_async：异步栅栏调用

---

(1) 解析pthread_rwlock读写锁

等待锁的线程会进入休眠

// 初始化锁
pthread_rwlock_t lock;
pthread_rwlock_init(&lock, NULL);
// 读 - 加锁
pthread_rwlock_rdlock(&lock);
// 读 - 尝试加锁
pthread_rwlock_tryrdlock(&lock);
// 写 - 加锁
pthread_rwlock_wrlock(&lock);
// 写 - 尝试加锁
pthread_rwlock_trywrlock(&lock);
// 解锁
pthread_rwlock_unlock(&lock);
// 销毁
pthread_rwlock_destroy(&lock);

实例分析：

// TODO: ----------------- ViewController类 -----------------
@interface ViewController ()
@property (nonatomic, assign) pthread_rwlock_t lock;
@end

@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];

    pthread_rwlock_init(&_lock, NULL);

    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    for (int i=0; i<5; i++) {
        dispatch_async(queue, ^{
            [self read];
        });
        dispatch_async(queue, ^{
            [self write];
        });
    }
}
// 允许多条线程同时 读取 操作
- (void)read {
    pthread_rwlock_rdlock(&_lock);
    sleep(1);
    NSLog(@"read");
    pthread_rwlock_unlock(&_lock);
}
// 不允许多条线程同时 写入 操作
- (void)write {
    pthread_rwlock_wrlock(&_lock);
    sleep(1);
    NSLog(@"write");
    pthread_rwlock_unlock(&_lock);
}
- (void)dealloc {
    pthread_rwlock_destroy(&_lock);
}
@end

打印结果

由打印结果可知：

同一时间，有多个线程进行读取的操作；只有1个线程进行写入的操作；
读取写入操作不会同时执行。

---

2) 解析dispatch_barrier_async异步栅栏调用

• 传入的并发队列必须是通过dispatch_queue_create创建的；
• 如果传入的是一个串行或是一个全局的并发队列，那这个函数便等同于dispatch_async函数的效果

// 初始化队列
dispatch_queue_t queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
// 读
dispatch_async(queue, ^{

});
// 写
dispatch_barrier_async(queue, ^{

});

实例分析：

// TODO: ----------------- ViewController类 -----------------
@interface ViewController ()
@property (nonatomic, strong) dispatch_queue_t queue;
@end

@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];

    self.queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
    for (int i=0; i<5; i++) {
        [self read];
        [self read];
        [self write];
        [self write];
    }
}
- (void)read {
    dispatch_async(self.queue, ^{
        sleep(1);
        NSLog(@"read");
    });
}
- (void)write {
    dispatch_barrier_async(self.queue, ^{
        sleep(1);
        NSLog(@"write");
    });
}
@end

打印结果

由打印结果可知：

同一时间，有多个线程进行读取的操作；只有1个线程进行写入的操作；
读取写入操作不会同时执行。