iOS 多线程与安全

作者: zaijianbali | 来源:发表于2017-05-25 20:19 被阅读242次

    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】的位置不是正确的数据,也就是说数组越界了

    image.png

    我们使用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 这种加锁方式开发速度很快,如果访问量小,其实性能是可以忽略的,所以,

    存在就是有必要的。

    以上为自己的观点看法,如果有不对的地方,请指教。

    本文解释权归:子文

    如需转载请注明出处,谢谢

    来杯可乐催更吧

    请子文喝可乐

    相关文章

      网友评论

      • 谢谢生活:遍历不可变修改可变,非常巧妙。
      • 谢谢生活:非常好,能讲点基础理论更好了
      • 木木等你:还是没看明白该怎么做,:smile:
        木木等你:@zaijianbali 经过仔细查看,终于算是看懂了一点信号量了。而且效率上讲,还是信号量高一些。但是关于 多线程的读写,还没看太深入
        zaijianbali:呵呵,刚开始写,一些东西还是不够深入分析,语言组织不是特别好,其次是多线程安全本省就是一个难点和痛点。多使用就知道,不要每次都局限自己使用synchronized。

      本文标题:iOS 多线程与安全

      本文链接:https://www.haomeiwen.com/subject/xiczxxtx.html