导语： 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）来不仅实现数据同步线程安全，还比串行同步队列方式更高效。
说明：栅栏块单独执行，不能与其他块并行。知道当前所有并发块都执行完毕，才会单独执行这个栅栏块。线程安全的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使用
//线程安全的NSMutableArray
QSThreadSafeMutableArray *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
2255
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
