面试题引发的思考：
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个线程进行写入的操作；
读取写入操作不会同时执行。
