iOS 多线程与安全
多核cpu,使用多线程,能明显提升性能,但如果使用不当,会造成严重的后果,轻则数据问题,重则crash
那么在使用多线程的时候应该注意哪些安全问题呢?
第一个问题就是数据一致性问题?
何种情况会出现数据一致性问题呢?
针对数据的增删改查,存在以下几种情况:
*读-读
*读-写
*写-读
*写-写
只有读-读可以并行
或者说只要是写都要串行
虽然我们可以使用synchronized 加锁
- (void)setName:(NSString *)name
{
@synchronized(self) {
_name = [name copy];
}
}
- (NSString *)name
{
@synchronized(self) {
return _name;
}
}
这也是初学iOS的时候,最简单的处理资源竞争问题的一种解决方案。
这种加锁的性能特别低,因为使用synchronized的话,系统为我们加锁的同时,也增加了异常处理,等于无形中增加了try-catch-finally 代码片段。
其次;如果block代码块内部耗时,那么性能就会变得更低,
还有就是;这个是对self加锁,如果其他地方还有对self加锁,频繁的加锁导致效率更低;
使用synchronized,方法,等于同步访问了,多线程变成了单线程。那么使用多线程就没有了意义。
上面的方法,等于在属性上加了atomic,可以查阅atomic的实现原理。
就算这样也不能保证;同一个线程读到的数据是一致的,也就是读-读也不能保证数据一致,就算在一个线程,因为其他线程可能存在写。
所以需要更改一种方法,防止出现数据不一致的问题,我们找到了
串行同步队列
static dispatch_queue_t _queue;
- (instancetype)init
{
if (self = [super init]) {
_queue = dispatch_queue_create("com.zw.syncQueue", DISPATCH_QUEUE_SERIAL);
}
return self;
}
- (void)setName:(NSString *)name
{
dispatch_sync(_queue, ^{
_name = [name copy];
});
}
- (NSString *)name
{
__block NSString *tempName;
dispatch_sync(_queue, ^{
tempName = _name;
});
return tempName;
}
这样所有访问都是同步的了,虽然问题解决了,但不是最优答案,
只能解决单读、单写的问题,我们的终极目标是
读-写,写-写 这种情况下不能被读(写的过程不能读)
读-读之间可以并行执行。
因此我们总结如下:
读-读 可以并发执行
读-写、写-写 不能并发执行,
因此我们把这个串行队列改成并行队列
static dispatch_queue_t _concurrentQueue;
- (instancetype)init
{
if (self = [super init]) {
_concurrentQueue = dispatch_queue_create("com.zw.syncQueue", DISPATCH_QUEUE_CONCURRENT);
}
return self;
}
- (void)setName:(NSString *)name
{
dispatch_barrier_async(_concurrentQueue, ^{
_name = [name copy];
});
}
- (NSString *)name
{
__block NSString *tempName;
dispatch_sync(_concurrentQueue, ^{
tempName = _name;
});
return tempName;
}
用到了dispatch_barrier_async 可以翻译为栅栏,功能是:增加了一个障碍物,之前加入队列的执行完后才能执行当前的代码片段,之后加入队列的需要等到dispatch_barrier_async 代码片段执行完成后才能执行。
这样就完美解决了读-读并行,读-写、写-写串行的问题。
以上参考了 iOS开发:深入理解GCD 第二篇(dispatch_group、dispatch_barrier、基于线程安全的多读单写)
集合访问问题
我们拿数组举个例子好了。
对数组的曹组操作,我们存在增 删 查(遍历) 改
我们可以理解为所有的都是串行的,
那么用atomic可以吗?
atomic并不能保证线程安全,比如通过index获取数组中的对象就有可能越界。
这个时候可以在任何使用的位置加锁也就是
synchronized 只要访问数组就加,无论增删改查,
同样的问题也存在,就是性能问题;
那么如何解决呢?我常用的操作如下:使用信号量机制
信号量机制本事也是锁的一种。
但不同的锁有不同的用处和性能。
#define Dispatch_Semaphore_Wait() dispatch_semaphore_wait(LOCK, DISPATCH_TIME_FOREVER)
#define Dispatch_Semaphore_Signal() dispatch_semaphore_signal(LOCK)
static dispatch_semaphore_t LOCK;
LOCK = dispatch_semaphore_create(1);
- (void)clearCaches{
Dispatch_Semaphore_Wait();
self.bigthumbnails = [NSMutableArray array];
self.thumbnails = [NSMutableArray array];
self.fileUrls = [NSMutableArray array];
self.selections = [NSMutableArray array];
Dispatch_Semaphore_Signal();
}
- (void)updateCacheBySortedArray:(NSArray *)sortedArray{
for (NSDictionary *eachAssetsInfo in sortedArray)
{
ALAsset *asset = [eachAssetsInfo objectForKey:kBIMPhotoAlbumInfoKeyAssets];
BIMPhotoAlbumMWPhoto *photo = [BIMPhotoAlbumMWPhoto photoWithURL:asset.defaultRepresentation.url];
BIMPhotoAlbumMWPhoto *thumb = [BIMPhotoAlbumMWPhoto photoWithImage:[UIImage imageWithCGImage:asset.thumbnail]];
Dispatch_Semaphore_Wait();
[self.fileUrls addObject:asset.defaultRepresentation.url.absoluteString];
[self.bigthumbnails addObject:photo];
[self.thumbnails addObject:thumb];
if (!self.selections) {
self.selections = [NSMutableArray new];
}
[self.selections addObject:[NSNumber numberWithBool:NO]];
Dispatch_Semaphore_Signal();
}//for
}
这种方式和使用synchronized 一样,就是性能的提升版而已,提升有一个量级吧,如果仔细研究下,同样也不能解决问题多线程的问题,但通过锁的方式已经将存在的crash降到了很低,可以不用考虑了。
还有一种方案还通过copy,
也就是说每次遍历的时候,都是用copy的一份,
- (void)updateCacheBySortedArray:(NSArray *)sortedArray{
NSArray *array = [sortedArray copy];
for (NSDictionary *eachAssetsInfo in array)
{
ALAsset *asset = [eachAssetsInfo objectForKey:kBIMPhotoAlbumInfoKeyAssets];
BIMPhotoAlbumMWPhoto *photo = [BIMPhotoAlbumMWPhoto photoWithURL:asset.defaultRepresentation.url];
BIMPhotoAlbumMWPhoto *thumb = [BIMPhotoAlbumMWPhoto photoWithImage:[UIImage imageWithCGImage:asset.thumbnail]];
[self.fileUrls addObject:asset.defaultRepresentation.url.absoluteString];
[self.bigthumbnails addObject:photo];
[self.thumbnails addObject:thumb];
if (!self.selections) {
self.selections = [NSMutableArray new];
}
[self.selections addObject:[NSNumber numberWithBool:NO]];
}//for
}
下面举个例子:
NSMutableArray *array =[NSMutableArray array];
for (int i =0; i< 100; i++) {
[array addObject:@(i)];
}
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[array removeObjectAtIndex:10];
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[array removeObjectAtIndex:10];
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[array removeObjectAtIndex:10];
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[array removeObjectAtIndex:10];
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// NSArray *arr = [array copy];
// for (NSNumber *num in arr) {
// NSLog(@"number=%@", num);
// }
for (NSNumber *num in array) {
NSLog(@"number=%@", num);
}
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[array removeObjectAtIndex:10];
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[array removeObjectAtIndex:10];
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[array removeObjectAtIndex:10];
});
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
[array removeObjectAtIndex:10];
});
多次运行,偶尔会出现crash,不是必现,
我是运行在 7PLUS 模拟器上,偶现crash
我们看一下crash现场
解释如下:在遍历可变数组的时候,很大的一个问题就是可变数组在遍历的过程中进行了数据更改,这会造成各种问题或者崩溃。
不光是在多线程中会有,甚至单线程中,使用不好同样会造成崩溃,就是因为在遍历的过程中,修改了数据长度或者是修改了数据元素。
image.png我们分析一下:100个数据,现场打印的数组个数是93个,不是92,所以一定是异步执行了,且数组遍历的时候,最后一个remove还没有执行。
其次,堆栈上第【92】的位置不是正确的数据,也就是说数组越界了
我们使用copy的话:也就是啊上面的注释代码打开
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
NSArray *arr = [array copy];
for (NSNumber *num in arr) {
NSLog(@"number=%@", num);
}
// for (NSNumber *num in array) {
// NSLog(@"number=%@", num);
// }
});
就没有发生crash,
那么如果想要在遍历的时候修改可变数组,如何避免上述问题呢?可以这样操作一下,就是在遍历之前先copy出来一个不可变数组arr,这样的copy是浅拷贝,而且必须使用浅拷贝。然后遍历这个不可变数组arr,在这个遍历的过程中来操作删除可变数组中的元素。因为是浅拷贝,所以遍历这个不可变数组中的对象,也实际就是可变数组中的对象。
不过还是存在问题,看看打印结果
image.png这个问题还在查询原因?求大神指教
那么,以上都在说synchronized 不好不好,那么还有存在的必要吗?
答案是肯定的,
对于不经常访问的数据,通过synchronized 这种加锁方式开发速度很快,如果访问量小,其实性能是可以忽略的,所以,
存在就是有必要的。
以上为自己的观点看法,如果有不对的地方,请指教。
本文解释权归:子文
如需转载请注明出处,谢谢
网友评论