Simple and effective thread-safe proxy that forwards all method invocations inside a locked scope. Definitely not the fastest thread-safe implementation ever.

ThreadSafeProxy.h

@import Foundation;


@interface NSObject (ThreadSafeProxy)

- (instancetype)threadSafe;

@end


@interface ThreadSafeProxy : NSProxy

- (instancetype)initWithObject:(NSObject *)underlaying;
@property (readonly) NSObject *underlaying;
@property (readonly) NSRecursiveLock *lock;

@end

ThreadSafeProxy.m

#import "ThreadSafeProxy.h"


@implementation ThreadSafeProxy

- (instancetype)initWithObject:(NSObject *)underlaying {
    self->_underlaying = underlaying;
    self->_lock = [NSRecursiveLock new];
    return self;
}

- (NSMethodSignature *)methodSignatureForSelector:(SEL)selector {
    return [self->_underlaying methodSignatureForSelector:selector];
}

- (void)forwardInvocation:(NSInvocation *)invocation {
    [self->_lock lock];
    [invocation invokeWithTarget:self->_underlaying];
    [self->_lock unlock];
}

@end


@implementation NSObject (ThreadSafeProxy)

- (instancetype)threadSafe {
    return (typeof(self))[[ThreadSafeProxy alloc] initWithObject:self];
}

@end

usage.m

NSMutableArray *processedArray = [[NSMutableArray new] threadSafe];

[existingArray enumerateObjectsWithOptions:NSEnumerationConcurrent usingBlock:^(id object, NSUInteger idx, BOOL *stop) {
    // ... concurrent processing ...
    [processedArray addObject:object];
}];