手记

NSMutableArray使用中忽视的问题

LEATH
2018-06-03 17:50:41浏览 3006

导语： NSMutableArray提供的API能解决绝大部分的需求，但是在实际iOS开发中，在某些场景下，需要考虑线程安全 或 弱对象引用 或 删除元素这三个问题。

一、线程安全的NSMutableArray####

NSMutableArray本身是线程不安全的。简单来说，线程安全就是多个线程访问同一段代码，程序不会异常、不Crash。而编写线程安全的代码主要依靠线程同步。

1、不使用atomic修饰属性

原因有二，如下：

1 ) atomic 的内存管理语义是原子性的，仅保证了属性的setter和getter方法是原子性的，是线程安全的，但是属性的其他方法，如数组添加/移除元素等并不是原子操作，所以不能保证属性是线程安全的。

2 ) atomic虽然保证了getter、setter方法线程安全，但是付出的代价很大，执行效率要比nonatomic慢很多倍(有说法是慢10-20倍)。

总之：使用nonatomic修饰NSMutableArray对象就可以了，而使用锁、dispatch_queue来保证NSMutableArray对象的线程安全。

2、打造线程安全的NSMutableArray

在《Effective Objective-C 2.0..》书中第41条：多用派发队列，少用同步锁中指出：使用“串行同步队列”（serial synchronization queue），将读取操作及写入操作都安排在同一个队列里，即可保证数据同步。而通过并发队列，结合GCD的栅栏块（barrier）来不仅实现数据同步线程安全，还比串行同步队列方式更高效。

GCD的栅栏块作用示意图.png

说明：栅栏块单独执行，不能与其他块并行。知道当前所有并发块都执行完毕，才会单独执行这个栅栏块。线程安全的NSMutableArray实现如下：

//QSThreadSafeMutableArray.h@interface QSThreadSafeMutableArray : NSMutableArray@end//QSThreadSafeMutableArray.m#import "QSThreadSafeMutableArray.h"@interface QSThreadSafeMutableArray()@property (nonatomic, strong) dispatch_queue_t syncQueue;@property (nonatomic, strong) NSMutableArray* array;@end@implementation QSThreadSafeMutableArray#pragma mark - init 方法- (instancetype)initCommon{    self = [super init];    if (self) {        //%p 以16进制的形式输出内存地址，附加前缀0x
        NSString* uuid = [NSString stringWithFormat:@"com.jzp.array_%p", self];        //注意：_syncQueue是并行队列
        _syncQueue = dispatch_queue_create([uuid UTF8String], DISPATCH_QUEUE_CONCURRENT);
    }    return self;
}

- (instancetype)init{    self = [self initCommon];    if (self) {
        _array = [NSMutableArray array];
    }    return self;
}//其他init方法略#pragma mark - 数据操作方法 (凡涉及更改数组中元素的操作，使用异步派发+栅栏块；读取数据使用 同步派发+并行队列)- (NSUInteger)count{

    __block NSUInteger count;    dispatch_sync(_syncQueue, ^{
        count = _array.count;
    });    return count;
}

- (id)objectAtIndex:(NSUInteger)index{

    __block id obj;    dispatch_sync(_syncQueue, ^{        if (index < [_array count]) {
            obj = _array[index];
        }
    });    return obj;
}

- (NSEnumerator *)objectEnumerator{

    __block NSEnumerator *enu;    dispatch_sync(_syncQueue, ^{
        enu = [_array objectEnumerator];
    });    return enu;
}

- (void)insertObject:(id)anObject atIndex:(NSUInteger)index{

    dispatch_barrier_async(_syncQueue, ^{        if (anObject && index < [_array count]) {
            [_array insertObject:anObject atIndex:index];
        }
    });
}

- (void)addObject:(id)anObject{

    dispatch_barrier_async(_syncQueue, ^{        if(anObject){
           [_array addObject:anObject];
        }
    });
}

- (void)removeObjectAtIndex:(NSUInteger)index{

    dispatch_barrier_async(_syncQueue, ^{    
        if (index < [_array count]) {
            [_array removeObjectAtIndex:index];
        }
    });
}

- (void)removeLastObject{

    dispatch_barrier_async(_syncQueue, ^{
        [_array removeLastObject];
    });
}

- (void)replaceObjectAtIndex:(NSUInteger)index withObject:(id)anObject{

    dispatch_barrier_async(_syncQueue, ^{        if (anObject && index < [_array count]) {
            [_array replaceObjectAtIndex:index withObject:anObject];
        }
    });
}

- (NSUInteger)indexOfObject:(id)anObject{

    __block NSUInteger index = NSNotFound;    dispatch_sync(_syncQueue, ^{        for (int i = 0; i < [_array count]; i ++) {            if ([_array objectAtIndex:i] == anObject) {
                index = i;                break;
            }
        }
    });    return index;
}

- (void)dealloc{    if (_syncQueue) {
        _syncQueue = NULL;
    }
}@end

说明1：使用dispatch queue来实现线程同步；将同步与异步派发结合起来，可以实现与普通加锁机制一样的同步行为，又不会阻塞执行异步派发的线程；使用同步队列及栅栏块，可以令同步行为更加高效。

说明2：NSMutableDictionary本身也是线程不全的，实现线程安全的NSMutableDictionary原理同线程安全的NSMutableArray。(代码见
QSUseCollectionDemo)

2、线程安全的NSMutableArray使用
//线程安全的NSMutableArrayQSThreadSafeMutableArray *safeArray = [[QSThreadSafeMutableArray alloc]init];dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);for (NSInteger i = 0; i < 10; i++) {    
    dispatch_async(queue, ^{        NSString *str = [NSString stringWithFormat:@"数组%d",(int)i+1];
        [safeArray addObject:str];
    });
}

sleep(1);NSLog(@"打印数组");
[safeArray enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {    
    NSLog(@"%@",obj);
}];

说明1：先要初始化QSThreadSafeMutableArray对象，初始化工作不是线程安全的。

说明2：多个线程几乎同时添加数据元素，使用QSThreadSafeMutableArray，没有发生遗漏数据，也没有因为资源竞争导致的奔溃。而NSMutableArray对象在同样情况下会出问题（遗漏数据 或 crash）。

二、NSMutableArray弱引用对象####

在iOS中，容器类是强引用其存储的元素的，将对象添加到容器时，该对象的引用计数+1，这很好保证了访问容器类中元素时，元素是始终存在容器类中。这种强引用同时也埋下了造成循环引用的可能。实现容器类中弱引用对象，是个考虑的问题。容器类中仅以NSMutableArray为例，实现弱引用对象、

1、NSMutableArray分类实现
//NSMutableArray+WeakReferences.h@interface NSMutableArray (WeakReferences)+ (id)mutableArrayUsingWeakReferences;

+ (id)mutableArrayUsingWeakReferencesWithCapacity:(NSUInteger)capacity;@end//NSMutableArray+WeakReferences.m#import "NSMutableArray+WeakReferences.h"@implementation NSMutableArray (WeakReferences)+ (id)mutableArrayUsingWeakReferences {    return [self mutableArrayUsingWeakReferencesWithCapacity:0];
}

+ (id)mutableArrayUsingWeakReferencesWithCapacity:(NSUInteger)capacity {    CFArrayCallBacks callbacks = {0, NULL, NULL, CFCopyDescription, CFEqual};    // Cast of C pointer type 'CFMutableArrayRef' (aka 'struct __CFArray *') to Objective-C pointer type 'id' requires a bridged cast
    return (id)CFBridgingRelease(CFArrayCreateMutable(0, capacity, &callbacks));    // return (id)(CFArrayCreateMutable(0, capacity, &callbacks));}@end

** 说明1 **: 参考自Non-retaining array for delegates

说明2：在NSDictionary/NSMutableDictionary中，也是强引用values。想弱引用values，只需要使用NSMapTable（iOS 6推出），它不仅和字典有相似的数据结构，还可以指定key是强引用，value是弱引用。

2、其他实现

思路：将需要添加到容器中的对象，包装在另一个存储对它的弱引用的对象中。

//QSWeakObjectWrapper.h@interface QSWeakObjectWrapper : NSObject@property (nonatomic, weak, readonly) id weakObject;

- (id)initWithWeakObject:(id)weakObject;@end//QSWeakObjectWrapper.m#import "QSWeakObjectWrapper.h"@implementation QSWeakObjectWrapper- (id)initWithWeakObject:(id)weakObject{    if (self = [super init]) {
        _weakObject = weakObject;
    }    return self;
}@end

** 说明 **: 我们实现了弱引用元素，即不希望数组保留对象，这是为了解决数组中循环引用的问题；但平时还是默认使用强引用数组元素，因为弱引用数组元素，数组中元素在释放，数组会出问题。

三、删除NSMutableArray中的元素####

1、removeObjectAtIndex VS removeObject

  • removeObjectAtIndex：删除指定NSMutableArray中指定index的对象( index不能越界）。

  • removeObject：删除NSMutableArray中所有isEqual:待删对象的对象

说明1：removeObjectAtIndex:最多只能删除一个对象，而removeObject:可以删除多个对象（只要符合isEqual:的都删除掉）。

说明2：在NSMutableArray遍历中使用removeObject:删除该NSMutableArray内部对象，此举可能引发误删

2、删除元素错误做法

下面罗列几种比较常见错误的做法

1） 在for in 循环中删除数组内部对象。

NSMutableArray *arr = [[NSMutableArray alloc]initWithObjects:@"1",@"2",@"3",@"3",@"4",@"3",@"5",@"3",@"6",nil];    
for (NSString *str in arr) {    if ([str isEqualToString:@"3"]) {        
        NSInteger index = [arr indexOfObject:@"3"];
        [arr removeObjectAtIndex:index];
    }
}

说明：在for in 循环中删除数组内部对象可能会引起崩溃。只有一种情况例外，在for in 循环中，如果删除的是数组中最后一个元素的话，程序就不会崩溃，这是因为当for in 循环遍历到最后一个元素时，已经遍历结束了。奔溃时候报错如下：

  *** Terminating app due to uncaught exception 'NSGenericException', reason: '*** Collection <__NSArrayM: 0x610000045040>
   was mutated while being enumerated.'

2）在for循环遍历中从前往后删除

NSMutableArray *arr = [[NSMutableArray alloc]initWithObjects:@"1",@"2",@"3",@"3",@"4",@"3",@"5",@"3",@"6",nil];    
for (NSInteger i = 0; i < [arr count]; i++) {    NSString *str = [arr objectAtIndex:i];    if ([str isEqualToString:@"3"]) {
        [arr removeObjectAtIndex:i];
    }
}

说明：如果是删除相同元素，相同元素相邻，会被漏删。有些童鞋在for循环遍历使用removeObject，可以做到不漏删，这是因为removeObject本身特点就是删除数组中所有isEqual:待删对象的对象。因之，掩盖了问题，那么做也是不对。

3、删除元素正确做法

1）直接使用removeObject（如果是删除相同元素）

因为其本身特点就是删除数组中所有isEqual:待删对象的对象，解决删除相同元素这种问题很适合，不需要在遍历时候使用。

2）在for循环遍历从后往前删除

NSMutableArray *arr = [[NSMutableArray alloc]initWithObjects:@"1",@"2",@"3",@"3",@"4",@"3",@"5",@"3",@"6",nil];for (NSInteger i = [arr count] - 1; i >= 0; i--) {    NSString *str = [arr objectAtIndex:i];    if ([str isEqualToString:@"3"]) {
        [arr removeObjectAtIndex:i];
    }
}

四、其他

  • Class Clusters（类簇）是抽象工厂模式在iOS下的一种实现，Class Clusters仅对外暴露出简单的接口，而隐藏了内部多个私有的类和方法的实现。NSMutableArray、NSMutableDictionary就是Class Clusters（类簇）中代表。

  • NSMutableArray/NSArray中存储的元素是允许重复的，其提供的常用接口的性能有差异。 indexOfObject: 、containsObject:、removeObject: 都会遍历数组中的元素，这意味着着调用这些接口，时间复杂度至少是O(n); 而objectAtIndex:、removeLastObject、firstObject、lastObject、addObject:这些接口的时间复杂度是O(1)。

  • NSArray提供的indexOfObject:inSortedRange:options:usingComparator: 使用的是二分查找，时间复杂度是 O(log n)。

     //比indexOfObject:的效率高
 NSArray *arr = [NSArray arrayWithObjects:@"5",@"1",@"2",@"4",@"3",nil]; NSLog(@"2 index = %ld",[arr indexOfObject:@"2" inSortedRange:NSMakeRange(0, [arr count]) options:NSBinarySearchingFirstEqual   usingComparator:^NSComparisonResult(id  _Nonnull obj1, id  _Nonnull obj2) {      if ([obj1 integerValue] > [obj2 integerValue]) {          return NSOrderedDescending; //
      }else if ([obj1 integerValue] < [obj2 integerValue]) {          return NSOrderedAscending;
      }      return NSOrderedSame;
  }]);

  • NSMutableArray/NSArray的排序。

     NSArray *arr = [NSArray arrayWithObjects:@"5",@"1",@"2",@"4",@"3",nil];  //递减排序
 NSArray *sortArray = [arr sortedArrayUsingComparator:^NSComparisonResult(id  _Nonnull obj1, id  _Nonnull obj2) {  if ([obj1 integerValue] > [obj2 integerValue]) {      return NSOrderedAscending; //
  }else if ([obj1 integerValue] < [obj2 integerValue]) {      return NSOrderedDescending;
  }  return NSOrderedSame;
}];NSLog(@"sortArray = %@",sortArray); //{"5","4","3","2","1"}

End



作者：南华coder
链接：https://www.jianshu.com/p/ed2030920ec4


相关标签
Android
iOS
0人推荐
随时随地看视频
慕课网APP

相关阅读

导入高德地图定位功能
什么是Handler
详解自动布局（Masonry）实现九宫格
Android 钱包支付之输入支付密码
iOS开发-自动打包神器