iOS中的多线程开发技术第四篇之IO操作

#import <Foundation/Foundation.h>

@interface BarrierExample : NSObject
@property (nonatomic, strong) dispatch_queue_t concurrentQueue;
@property (nonatomic, strong) NSMutableArray *dataArray;
@end

@implementation BarrierExample

- (instancetype)init {
    self = [super init];
    if (self) {
        // 创建一个并发队列
        _concurrentQueue = dispatch_queue_create("com.example.concurrentQueue", DISPATCH_QUEUE_CONCURRENT);
        _dataArray = [NSMutableArray array];
    }
    return self;
}

// 读取操作
- (void)readData {
    dispatch_async(self.concurrentQueue, ^{
        NSLog(@"Reading data: %@", self.dataArray);
    });
}

// 写入操作
- (void)writeData:(id)data {
    dispatch_barrier_async(self.concurrentQueue, ^{
        [self.dataArray addObject:data];
        NSLog(@"Writing data: %@", self.dataArray);
    });
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        BarrierExample *example = [[BarrierExample alloc] init];
        
        // 模拟多线程读写
        for (int i = 0; i < 5; i++) {
            dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
                [example readData];
            });
        }
        
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            [example writeData:@"New Data"];
        });
        
        // 延时以确保任务完成
        sleep(1);
    }
    return 0;
}

输出示例：

Reading data: ()
Reading data: ()
Writing data: ("New Data")
Reading data: ("New Data")
Reading data: ("New Data")

读操作并发执行，效率高。

写操作确保独占性，数据安全。

2.应用场景:缓存系统

在缓存系统中，读取数据可以并发进行，但写入需要独占队列，确保数据一致性:

- (id)readFromCache {
    __block id result = nil;
    dispatch_sync(self.concurrentQueue, ^{
        result = [self.cache objectForKey:@"key"];
    });
    return result;
}

- (void)writeToCache:(id)value {
    dispatch_barrier_async(self.concurrentQueue, ^{
        [self.cache setObject:value forKey:@"key"];
    });
}

5.注意事项

1.屏障任务对队列的影响

只能在自定义并发队列中起作用。

在全局并发队列中不会阻塞其他任务。

2.性能优化

读操作不会阻塞，性能高。

写操作独占队列，适合写入频率较低的场景。

3.不要滥用屏障任务

如果数据写入频繁，屏障任务可能会成为性能瓶颈。

对于写入频繁的场景，考虑其他机制（如 pthread_rwlock 或 NSLock）。

2.pthread_rwlock

pthread_rwlock 是 POSIX 提供的读写锁，专为多读少写场景设计。

它提供两种操作：

pthread_rwlock_rdlock：加读锁，允许多个线程同时读取。
pthread_rwlock_wrlock：加写锁，独占资源。

示例代码

#import <Foundation/Foundation.h>
#import <pthread.h>

@interface RWLockExample : NSObject
@property (nonatomic, strong) NSMutableArray *dataArray;
@property (nonatomic) pthread_rwlock_t rwLock;
@end

@implementation RWLockExample

- (instancetype)init {
    self = [super init];
    if (self) {
        _dataArray = [NSMutableArray array];
        pthread_rwlock_init(&_rwLock, NULL); // 初始化读写锁
    }
    return self;
}

- (void)dealloc {
    pthread_rwlock_destroy(&_rwLock); // 销毁读写锁
}

// 读取操作
- (void)readData {
    pthread_rwlock_rdlock(&_rwLock); // 加读锁
    NSLog(@"Reading data: %@", self.dataArray);
    pthread_rwlock_unlock(&_rwLock); // 解锁
}

// 写入操作
- (void)writeData:(id)data {
    pthread_rwlock_wrlock(&_rwLock); // 加写锁
    [self.dataArray addObject:data];
    NSLog(@"Writing data: %@", self.dataArray);
    pthread_rwlock_unlock(&_rwLock); // 解锁
}

@end

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        RWLockExample *example = [[RWLockExample alloc] init];
        
        // 模拟多线程读写
        for (int i = 0; i < 5; i++) {
            dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
                [example readData];
            });
        }
        
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            [example writeData:@"New Data"];
        });
        
        sleep(1);
    }
    return 0;
}

1.优势

高度灵活，可精确控制读写锁的加锁和解锁。

性能优秀，尤其适合高并发读操作。

2.缺点

代码复杂度较高。

手动管理锁容易导致死锁或解锁失败。

三、方案对比

特性	dispatch_barrier_async	pthread_rwlock
实现复杂度	低	高
性能	适中	较高
适用场景	数据量较小，非实时要求场景	数据量较大，高实时性要求场景
灵活性	较低	高
推荐程度	中	高