建立一个原子NSMutableArray类

在Cocoa Framework以及GNUStep的Foundation库中，NSMutableArray以及NSMutableDictionary的设计不是多线程安全的，当然这种设计的好处是处理速度快，不需要任何锁进行同步，所以我们在使用Objective-C的这些容器的时候需要注意，在哪个线程中创建它们就在哪个线程中对它们进行操作。不过在某些情况下，我们由于一些算法或业务需求，需要在多个线程中共享一个NSMutableArray容器对象，这时候我们需要通过一些同步机制来实现多线程操作的安全性。

在诸多同步方法中，使用原子操作无疑是轻量且能保证多核多线程安全的，因此这里就通过原子操作来实现一个多核多线程安全的NSMutableArray类。这里采用的方法是将NSMutableArray对象以聚合的方式作为自定义数组类的一个成员属性。这么做的好处是灵活、可裁剪，同时对于全局名字空间也不会造成太过混乱的问题，尽管我们也可以用Category对已有的NSMutableArray类进行扩充，但过度滥用Category反而会让整个项目的名字空间造成混乱。

#import <Foundation/Foundation.h>

#include <stdalign.h>
#include <stdatomic.h>

#if  defined(__i386__) || defined(__x86_64__)
#define CPU_PAUSE()     asm("pause")
#elif defined(__arm__) || defined(__arm64__)
#define CPU_PAUSE()     asm("yield")
#else
#define CPU_PAUSE()
#endif

@interface ZCAtomicMutableArray<__covariant T> : NSObject

- (instancetype)initWithArray:(NSArray<T>*)array;
- (void)addObject:(T)object;
- (void)removeObject:(T)object;
- (void)removeObjectAtIndex:(NSUInteger)index;
- (void)setObject:(T)anObject atIndexedSubscript:(NSUInteger)index;
- (T)objectAtIndexedSubscript:(NSUInteger)index;
- (NSUInteger)count;
- (NSMutableArray*)getUnsafeArray;

@end

@implementation ZCAtomicMutableArray
{
@private

    NSMutableArray *mArray;
    atomic_int alignas(16) mFlag;
}

- (instancetype)initWithArray:(NSArray*)array
{
    self = [super init];
    
    if(array == nil)
        mArray = [[NSMutableArray alloc] initWithCapacity:1024];
    else
        mArray = [[NSMutableArray alloc] initWithArray:array];
    
    atomic_init(&mFlag, 1);
    
    return self;
}

- (void)dealloc
{
    while(atomic_exchange(&mFlag, 0) == 0)
        CPU_PAUSE();
    
    [mArray removeAllObjects];
    [mArray release];
    
    atomic_store(&mFlag, 1);
    
    NSLog(@"ZCAtomicMutableArray deallocated!");
    
    [super dealloc];
}

- (void)addObject:(id)object
{
    while(atomic_exchange(&mFlag, 0) == 0)
        CPU_PAUSE();
    
    [mArray addObject:object];
    
    atomic_store(&mFlag, 1);
}

- (void)removeObject:(id)object
{
    while(atomic_exchange(&mFlag, 0) == 0)
        CPU_PAUSE();
    
    [mArray removeObject:object];
    
    atomic_store(&mFlag, 1);
}

- (void)removeObjectAtIndex:(NSUInteger)index
{
    while(atomic_exchange(&mFlag, 0) == 0)
        CPU_PAUSE();
    
    [mArray removeObjectAtIndex:index];
    
    atomic_store(&mFlag, 1);
}

- (void)setObject:(id)anObject atIndexedSubscript:(NSUInteger)index
{
    while(atomic_exchange(&mFlag, 0) == 0)
        CPU_PAUSE();
    
    [mArray setObject:anObject atIndexedSubscript:index];
    
    atomic_store(&mFlag, 1);
}

- (id)objectAtIndexedSubscript:(NSUInteger)index
{
    while(atomic_exchange(&mFlag, 0) == 0)
        CPU_PAUSE();
    
    id ret = [mArray objectAtIndexedSubscript:index];
    
    atomic_store(&mFlag, 1);
    
    return ret;
}

- (NSUInteger)count
{
    while(atomic_exchange(&mFlag, 0) == 0)
        CPU_PAUSE();
    
    NSUInteger length = mArray.count;
    
    atomic_store(&mFlag, 1);
    
    return length;
}

- (NSMutableArray*)getUnsafeArray
{
    return mArray;
}

@end

int main(int argc, const char * argv[])
{
    @autoreleasepool 
    {
        ZCAtomicMutableArray<NSNumber*> *array = [[ZCAtomicMutableArray alloc] initWithArray:@[@10, @20, @30, @40, @50]];
        NSLog(@"The count is: %tu", [array count]);
        
        NSProcessInfo *proc = [NSProcessInfo processInfo];
        
        NSTimeInterval beginTime = proc.systemUptime;
        
        for(int i = 0; i < 1000000; i++)
            [array addObject:@(i)];
        
        NSLog(@"Time spent: %f", (proc.systemUptime - beginTime) * 1000.0);
        
        [array release];
        
        NSMutableArray *ma = [[NSMutableArray alloc] initWithCapacity:1024];
        
        beginTime = proc.systemUptime;
        
        for(int i = 0; i < 1000000; i++)
            [ma addObject:@(i)];
        
        NSLog(@"Time spent: %f", (proc.systemUptime - beginTime) * 1000.0);
        [ma release];
        
        array = [[ZCAtomicMutableArray alloc] initWithArray:nil];
        
        __block BOOL isComplete = NO;
        
        beginTime = proc.systemUptime;
        
        dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0), ^void(void) {
            for(int i = 0; i < 500000; i++)
                [array addObject:@(i)];
            
            isComplete = YES;
        });
        
        for(int i = 500000; i < 1000000; i++)
            [array addObject:@(i)];
        
        while(!isComplete)
            CPU_PAUSE();
        
        NSLog(@"Time spent: %f", (proc.systemUptime - beginTime) * 1000.0);
        
        uint64 sum = 0;
        
        // Test
        for(int i = 0; i < 1000000; i++)
            sum += array[i].intValue;
        
        [array release];
        
        NSLog(@"sum = %llu", sum);
        
        sum = 0;
        for(int i = 0; i < 1000000; i++)
            sum += i;
        
        NSLog(@"test sum = %llu", sum);
    }
}

以上代码是在macOS 10.12中完成的，当然各位也可以把它放到Linux下运行，安装Clang编译器以及GNUStep库、libdispatch-dev库即可。我们在main函数的最后部分可以看到，使用双核两个线程对同一个array对象操作完全没有问题。但是，如果这里的array是NSMutableArray类型的话，那么在运行时就会引发崩溃。