自旋锁:它是为实现保护共享资源而提出的一种锁机制。
自旋锁与互斥锁比较类似,它们都是为了解决对某项资源的互斥使用。
无论是互斥锁,还是自旋锁,在任何时刻,最多只能有一个保持者,也就说,在任何时刻最多只能有一个执行单元获得锁。
调度机制上略有不同:
互斥锁:如果资源已经被占用,资源申请者只能进入睡眠状态。
自旋锁:不会引起调用者睡眠,如果自旋锁已经被别的执行单元保持,调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁,"自旋"一词就是因此而得名。
可能存在两个问题:
试图递归地获得自旋锁必然会引起死锁:递归程序的持有实例在第二个实例循环,以试图获得相同自旋锁时,不会释放此自旋锁。在递归程序中使用自旋锁应遵守下列策略:递归程序决不能在持有自旋锁时调用它自己,也决不能在递归调用时试图获得相同的自旋锁。此外如果一个进程已经将资源锁定,那么,即使其它申请这个资源的进程不停地疯狂“自旋”,也无法获得资源,从而进入死循环。
过多占用cpu资源。如果不加限制,由于申请者一直在循环等待,因此自旋锁在锁定的时候,如果不成功,不会睡眠,会持续的尝试,单cpu的时候自旋锁会让其它process动不了. 因此,一般自旋锁实现会有一个参数限定最多持续尝试次数. 超出后, 自旋锁放弃当前time slice. 等下一次机会。
//属性
@property (atomic ,strong) NSString *name;
//对name赋值
self.name = @"iOS";
//原子性操作:
void objc_setProperty_atomic(id self, SEL _cmd, id newValue, ptrdiff_t offset)
{
//其实这里之前就已经看过了,setter底层都会调用reallySetProperty,工厂模式嘛
reallySetProperty(self, _cmd, newValue, offset, true, false, false);
}
//非原子性
void objc_setProperty_nonatomic(id self, SEL _cmd, id newValue, ptrdiff_t offset)
{
reallySetProperty(self, _cmd, newValue, offset, false, false, false);
}
//上面都会调用reallySetProperty,只有第五个参数传递的值不一致!!!!看下面的reallySetProperty方法实现,第五个参数就是 bool atomic
/**
self:隐含参数,对象消息接收者
_cmd:隐含参数,SEL方法编号
newValue:需要赋值的传入
offset:属性所在指针的偏移量
atomic:是否是原子操作
copy:是否是浅拷贝
mutableCopy:是否是深拷贝
*/
static inline void reallySetProperty(id self, SEL _cmd, id newValue, ptrdiff_t offset, bool , 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 {
//原子性走这里
/**
StripedMap PropertyLocks;
using spinlock_t = mutex_tt;
template
class mutex_tt : nocopy_t {
os_unfair_lock mLock;
public:
constexpr mutex_tt() : mLock(OS_UNFAIR_LOCK_INIT) {
lockdebug_remember_mutex(this);
}
constexpr mutex_tt(const fork_unsafe_lock_t unsafe) : mLock(OS_UNFAIR_LOCK_INIT) { }
void lock() {
lockdebug_mutex_lock(this);
os_unfair_lock_lock_with_options_inline(&mLock, OS_UNFAIR_LOCK_DATA_SYNCHRONIZATION);
}
void unlock() {
lockdebug_mutex_unlock(this);
os_unfair_lock_unlock_inline(&mLock);
}
......
}
*/
//先获取了spinlock_t锁
spinlock_t& slotlock = PropertyLocks[slot];
slotlock.lock();//加锁
//新旧值替换
oldValue = *slot;
*slot = newValue;
//解锁
slotlock.unlock();
}
//释放旧值
objc_release(oldValue);
}
//atomic原子性传入的bool值
id objc_getProperty(id self, SEL _cmd, ptrdiff_t offset, BOOL atomic) {
if (offset == 0) {
return object_getClass(self);
}
//获取加盐哈希表对应的值
id *slot = (id*) ((char*)self + offset);
//传入的值为false,表示不是原子性的,直接返回获取到的值
if (!atomic) return *slot;
//这里表示传入的atomic值为true,与setter一样,
//获取一把锁,加锁,获取到值,解锁,最后返回获取的值
spinlock_t& slotlock = PropertyLocks[slot];
slotlock.lock();
id value = objc_retain(*slot);
slotlock.unlock();
//为了提高性能,我们(安全地)在自旋锁之外自动释放。
return objc_autoreleaseReturnValue(value);
}
//atomic修饰
@property (atomic, strong) NSArray *atomicArr;
- (void)wm_test_atomic {
//异步任务 A
dispatch_async(dispatch_get_global_queue(0, 0), ^{
for (int i = 0; i < 100000; i ++) {
if (i % 2 == 0) {
self.atomicArr = @[@"I", @"Love", @"VN"];
} else {
self.atomicArr = @[@"I can do five in a row"];
}
NSLog(@"异步任务 A: %@\n", self.atomicArr);
}
});
//异步任务 B
dispatch_async(dispatch_get_global_queue(0, 0), ^{
for (int i = 0; i < 100000; i ++) {
NSString* str = [self.atomicArr objectAtIndex:1];
NSLog(@"异步任务 B ==== %@",str);
}
});
}
//这里运行的话会出现数组越界的crash
//atomic只是保证了setter/getter的安全,外部多线程操作,只有我们自己保证安全
//atomic修饰
@property (atomic ,assign) int num;
- (void)wm_test_atomic {
//异步任务 A
dispatch_async(dispatch_get_global_queue(0, 0), ^{
for (int i = 0; i < 20000; i ++) {
self.num = self.num+1;
NSLog(@"异步任务 A:%@------%d",NSThread.currentThread,self.num);
}
});
//异步任务 B
dispatch_async(dispatch_get_global_queue(0, 0), ^{
for (int i = 0; i < 20000; i ++) {
self.num = self.num+1;
NSLog(@"异步任务 B:%@------%d",NSThread.currentThread,self.num);
}
});
}
//打印结果?