1.atomic
首先要明确的是, 实际上atomic是安全的, 而且是绝对安全的.
atomic实际上就是原子操作, 所谓原子, 就是不可再分割, 已经是最小的操作单位了(所谓操作指的是对内存的读写), 很多在讨论OC下的atomic不安全, 不能保证数据的并发性, 认为atomic本身是不安全的, 实际上, 并非atomic不安全.
一个数据的线程安全, 简单说就是这部分的数据即使有多个线程同时读写, 也不会出现数据错乱的情况, 内存的最后状态总是可以预见的, 如果这块内存的数据被一个多线程读写之后, 出现的结果是不可预见的, 那么就可以说这块内存是"线程不安全的".
给一个属性添加了atomic做修饰,可以保证原子的属性setter和getter都是原子操作,也就是保证setter和getter内部是线程同步的.
//加了atomic的代码就是
@interface Person :NSObject
@property(atomic,copy) NSString *name
@end
@implementation Person
-(void)setName:(NSString *) name{
//加锁
_name = name;
//解锁
}
@end
对于这部分代码的验证,我们可以通过对于源码的研读得出结论,源码在objc4的objc-accessors.mm.
set方法的实现:
static inline void reallySetProperty(id self, SEL _cmd, id newValue, ptrdiff_t offset, bool atomic, bool copy, bool mutableCopy)
{
if (offset == 0) {
object_setClass(self, newValue);
return;
}
id oldValue;
id *slot = (id*) ((char*)self + offset);
if (copy) {
newValue = [newValue copyWithZone:nil];
} else if (mutableCopy) {
newValue = [newValue mutableCopyWithZone:nil];
} else {
if (*slot == newValue) return;
newValue = objc_retain(newValue);
}
if (!atomic) {
oldValue = *slot;
*slot = newValue;
} else {
spinlock_t& slotlock = PropertyLocks[slot];
slotlock.lock();
oldValue = *slot;
*slot = newValue;
slotlock.unlock();
}
objc_release(oldValue);
}
getter部分的实现:
id objc_getProperty(id self, SEL _cmd, ptrdiff_t offset, BOOL atomic) {
if (offset == 0) {
return object_getClass(self);
}
// Retain release world
id *slot = (id*) ((char*)self + offset);
if (!atomic) return *slot;
// Atomic retain release world
spinlock_t& slotlock = PropertyLocks[slot];
slotlock.lock();
id value = objc_retain(*slot);
slotlock.unlock();
// for performance, we (safely) issue the autorelease OUTSIDE of the spinlock.
return objc_autoreleaseReturnValue(value);
}
我们通过对于源码的研读感觉上,atomic实际上相当于一个引用计数器, 如果被标记了atomic, 那么被标记了的内存本身就有了一个引用计数器, 第一个占用这块内存的线程, 会给这个计数器+1, 在这个线程操作这块内存期间, 其他线程在访问这个内存的时候, 如果发现"引用计数器"不为0, 则阻塞, 实际上阻塞并不等于休眠, 它是基于CPU轮询, 休眠除非被唤醒, 否则无法继续执行, 阻塞则不同, 每个CPU轮询片到这个线程的时候都会尝试继续往下执行, 可见阻塞相对于休眠来讲, 阻塞是主动的, 休眠是被动的, 如果引用计数器为0, 轮询片到这,则先给这块内存的引用计数器+1, 然后再去操作, atomic实现操作序列化的具体过程大概是就是这样.
atomic: 原子属性, 线程安全, 效率较低. 可以当成人通过一扇门, 一次只能通过一个人.
nonatomic: 非原子属性, 线程不安全, 效率高. 可以多个人同时进出门.
其实atomic是安全的,但是它并不能保证使用属性的过程是线程安全的.
@property (strong, atomic) NSMutableArray *data;
Person *p = [[Person alloc] init];
p.data = [NSMutableArray array];
// 以下操作就不能保证线程安全了
for (int i = 0; i < 10; i++) {
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[p.data addObject:@"1"];
});
}
虽然data属性是声明为atomic,但是也只是在p.data(实际上调用了get方法)和p.data = [NSMutableArray array];(实际上调用了set方法)是安全的。但是多条线程同时添加对象时，即[p.data addObject:@"1"];并不能保证线程安全。
2.读写安全
对于文件的读写安全我们想去实现"多读单写"的思路,那我们如何可以实现以下场景:
①.同一时间，只能有1个线程进行写的操作.
②.同一时间，允许有多个线程进行读的操作.
③.同一时间，不允许既有写的操作，又有读的操作.
上面的场景就是典型的“多读单写”，经常用于文件等数据的读写操作，iOS中的实现方案有:
①.pthread_rwlock：读写锁.
②.dispatch_barrier_async : 异步栅栏调用.
一.pthread_rwlock
pthread_rwlock读写锁，顾名思义是用来解决读和写的矛盾。读操作可以共享，写操作是独占或者说是排他的。简单点说就是，读的时候可以很多线程去读，写的时候只有一个线程在写，而且写的时候不允许读操作。(等待的线程会去休眠)
pthread_rwlockAPI
\\初始化加锁
1.pthread_rwlock_t lock;
pthread_rwlock_init(&lock,NULL);
\\读写加锁
2.pthread_rwlock_rdlock(&lock);
\\读尝试加锁
3.pthread_rwlock_tryrdlock(&lock);
\\写加锁
4.pthread_rwlock_wrlock(&lock);
\\写尝试加锁
5.pthread_rwlock_trywrlock(&lock);
\\解锁
6.pthread_rwlock_unlock(&lock);
\\销毁锁
7.pthread_rwlock_destroy(&lock);
demo
#import <pthread.h>
@property (assign, nonatomic) pthread_rwlock_t lock;
- (void)viewDidLoad {
[super viewDidLoad];
// 初始化锁
pthread_rwlock_init(&_lock, NULL);
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
for (int i = 0; i < 10; i++) {
dispatch_async(queue, ^{
[self read];
});
dispatch_async(queue, ^{
[self write];
});
}
}
- (void)read {
pthread_rwlock_rdlock(&_lock);
sleep(1);
NSLog(@"%s", __func__);
pthread_rwlock_unlock(&_lock);
}
- (void)write {
pthread_rwlock_wrlock(&_lock);
sleep(1);
NSLog(@"%s", __func__);
pthread_rwlock_unlock(&_lock);
}
- (void)dealloc {
pthread_rwlock_destroy(&_lock);
}
二.dispatch_barrier_async
dispatch_barrier_async栅栏函数在使用的过程中会有两个注意点需要注意一下:
- 这个函数传入的并发队列必须是自己通过
dispatch_queue_cretate创建的.- 如果传入的是一个串行或是一个全局的并发队列，那这个函数便等同于1dispatch_async1函数的效果.
//重要方法
// 初始化队列
dispatch_queue_t queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
// 读
dispatch_async(self.queue, ^{
[self read];
});
// 写
dispatch_barrier_async(self.queue, ^{
[self write];
});
demo
@property (strong, nonatomic) dispatch_queue_t queue;
// 栅栏
- (void)barrier_async_test {
self.queue = dispatch_queue_create("rw_queue", DISPATCH_QUEUE_CONCURRENT);
for (int i = 0; i < 5; i++) {
dispatch_async(self.queue, ^{
[self read];
});
dispatch_async(self.queue, ^{
[self read];
});
dispatch_barrier_async(self.queue, ^{
[self write];
});
}
}
- (void)read {
sleep(1);
NSLog(@"read");
}
- (void)write {
sleep(1);
NSLog(@"write");
}
想了解更多iOS学习知识请联系:QQ(814299221)
网友评论