第四章 并发编程

4.1 线程

• 线程是运行时执行的一组指令序列
• 每个进程至少应包含一个线程
• 在iOS中，进程启动时的主要线程通常称作主线程
• 所有的UI元素都需要在主线程中创建和管理
• Cocoa编程不允许其他线程更新UI元素
• 涉及到UI操作的，都会将上下文鞋换到主线程再更新UI

4.2 线程开销

• 线程不仅有创建时的时间开销，还会消耗内核的内存
• 每个线程大约消耗1KB的内核内存空间
• 这块内存用于存储与线程有关的数据结构和属性，此处无法被分页
• 主线程的栈空间为1M，而且无法修改
• 所有的二级线程默认分配到512kb的栈空间
• 完整的栈并不会立即创建出来，实际的栈空间大小会随着使用而增长，因此即使主线程有1MB的栈空间某个时间点的实际栈空间很可能要小很多
• 在线程启动前，栈空间的大小可以被改变，栈空间的最小值为16KB，而且其数值必须是4KB的倍数
• iPhone 6 plus iOS 8.4 创建线程耗时4-5毫秒
• 启动线程的耗时5-100毫秒，平均29毫秒，开销主要来源于上下文切换

4.3 GCD

• GCD线程池中，线程上限是64个

4.4 操作与队列

• NSOperation封装了一个任务以及和任务相关的数据和代码，而NSOperationQueue以先入先出的顺序控制这一类任务的执行
• NSOperation和NSOperationQueue都提供控制线程个数的能力，可以控制队列的个数也能控制每个队列的线程个数
• GCD:
  
  1.抽象程度最高
  
  2.两种队列开箱即用:main和global
  
  3.可以创建更多的队列
  
  4.可以请求独占(dispatch_barrier_sync和dispatch_barrier_async)
  
  5.基于线程管理
  
  6.硬性限制创建64个线程
  
• NSOperationQueue:
  
  1.无默认队列
  
  2.应用管理自己创建的队列
  
  3.队列是优先级队列
  
  4.操作可以有不同的优先级(queuePriority属性)
  
  5.使用cancel消息可以取消操作，注：cancel只是标记，如果操作已经开始执行，则可能会继续执行下去
  
  6.可以等待某个操作执行完毕
  
• NSThread:
  
  1.低级别构造，最大化控制
  
  2.应用创建并管理线程
  
  3.应用创建并管理线程池
  
  4.应用启动线程
  
  5.线程可以拥有优先级，操作系统会根据优先级调度他们的执行
  
  6.无直接API用于等待线程完成,需要使用互斥量(NSLock)和自定义代码
  
• NSOperationQueue是多核安全

4.5.1 原子属性

• 线程安全通俗的理解为：多个线程并行执行，不会产生任何副作用
• 标记为atomic只能阻止并行修改 ,并不能保证线程安全

4.5.2 同步块

• 使用@synchronized保证了任何时候都只能被一个线程执行，使用如下：
  

@synchronized(instance){
        
}

4.5.3 锁

• 锁可以认为是低级别工具，atomic和@synchronized为高级封装(抽象)

- (instancetype)init {
    self = [super init];
    if (self) {
        self -> lock  = [NSLock new];
        self -> reLock = [NSRecursiveLock new];
    }
    return self;
}
- (void)test {
    [self->lock lock];
    //线程安全的代码
    [self->lock unlock];
}

• 注意死锁:
  

- (void)test {
    [self->lock lock];
    //线程安全的代码
    NSLog(@"test");
    [self test1];
    [self->lock unlock];
}

- (void)test1 {
    //会死锁
    [self->lock lock];
    NSLog(@"test1");
    [self->lock unlock];
}

• 避免上述情况，可以使用递归锁
  

- (void)test2 {
    [self->reLock lock];
    //线程安全的代码
    NSLog(@"test2");
    [self test3];
    [self->reLock unlock];
}

- (void)test3 {
    [self->reLock lock];
    //线程安全的代码
    NSLog(@"test3");
    [self->reLock unlock];
}

• NSCondition：
• 生产者、消费者

@interface Producer:NSObject

@property (nonatomic, strong) NSCondition *condition;
@property (nonatomic, strong) NSMutableArray *collector;
@property (nonatomic, assign) BOOL shouldProduce;

- (instancetype)initWithCondition:(NSCondition *)condition collector:(NSMutableArray *)collector;
- (void)produce;

@end

@implementation Producer

- (instancetype)initWithCondition:(NSCondition *)condition collector:(NSMutableArray *)collector {
    if (self = [super init]) {
        self.condition = condition;
        self.collector = collector;
        self.shouldProduce = NO;
    }
    return self;
}

- (void)produce {
    self.shouldProduce = YES;
    while (self.shouldProduce) {
        [self.condition lock];
        if (self.collector.count) {
            [self.condition wait];
        }
        [self.collector addObject:@"x"];
        [self.collector addObject:@"x"];
        NSLog(@"produce");
        [self.condition signal];
        [self.condition unlock];
    }
}

@end

@interface Customer:NSObject

@property (nonatomic, strong) NSCondition *condition;
@property (nonatomic, strong) NSMutableArray *collector;
@property (nonatomic, assign) BOOL shouldConsume;

- (instancetype)initWithCondition:(NSCondition *)condition collector:(NSMutableArray *)collector;
- (void)consume;

@end

@implementation Customer

- (instancetype)initWithCondition:(NSCondition *)condition collector:(NSMutableArray *)collector {
    if (self = [super init]) {
        self.condition = condition;
        self.collector = collector;
        self.shouldConsume = NO;
    }
    return self;
}

- (void)consume {
    self.shouldConsume = YES;
    while (self.shouldConsume) {
        [self.condition lock];
        if (self.collector.count) {
            [self.condition wait];
        }
        [self.collector removeObjectAtIndex:0];
        NSLog(@"consume");
        [self.condition signal];
        [self.condition unlock];
    }
}

@end

4.5.4 将读写锁应用于并发读写

• 并行读取，写入互斥的一种机制--读写锁
  
• 可以用(dispatch_barrier_sync或dispatch_barrier_async)