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现场
解释如下：在遍历可变数组的时候，很大的一个问题就是可变数组在遍历的过程中进行了数据更改，这会造成各种问题或者崩溃。
不光是在多线程中会有，甚至单线程中，使用不好同样会造成崩溃，就是因为在遍历的过程中，修改了数据长度或者是修改了数据元素。
我们分析一下：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，在这个遍历的过程中来操作删除可变数组中的元素。因为是浅拷贝，所以遍历这个不可变数组中的对象，也实际就是可变数组中的对象。
不过还是存在问题，看看打印结果
这个问题还在查询原因？求大神指教
那么，以上都在说synchronized 不好不好，那么还有存在的必要吗？
答案是肯定的，
对于不经常访问的数据，通过synchronized 这种加锁方式开发速度很快，如果访问量小，其实性能是可以忽略的，所以，
存在就是有必要的。
以上为自己的观点看法，如果有不对的地方，请指教。
本文解释权归：子文
如需转载请注明出处，谢谢
来杯可乐催更吧
