iOS多线程

2017-10-10 本文已影响0人 Alfred的记录本

NSOperation

NSOperation有两个常用子类用于创建线程操作：NSInvocationOperation和NSBlockOperation，两种方式本质没有区别，但是是后者使用Block形式进行代码组织，使用相对方便。

-(void)loadImageWithMultiThread{
    /*创建一个调用操作
     object:调用方法参数
    */
    NSInvocationOperation *invocationOperation=[[NSInvocationOperation alloc]initWithTarget:self selector:@selector(loadImage) object:nil];
    //创建完NSInvocationOperation对象并不会调用，它由一个start方法启动操作，但是注意如果直接调用start方法，则此操作会在主线程中调用，一般不会这么操作,而是添加到NSOperationQueue中
//    [invocationOperation start];
    
    //创建操作队列
    NSOperationQueue *operationQueue=[[NSOperationQueue alloc]init];
    //注意添加到操作队后，队列会开启一个线程执行此操作
    [operationQueue addOperation:invocationOperation];
}

//直接使用操队列添加操作
        [operationQueue addOperationWithBlock:^{
            [self loadImage:[NSNumber numberWithInt:i]];
        }];

或

        //创建多线程操作
        NSBlockOperation *blockOperation=[NSBlockOperation blockOperationWithBlock:^{
            [self loadImage:[NSNumber numberWithInt:i]];
        }];
        //创建操作队列

        [operationQueue addOperation:blockOperation];

创建完NSInvocationOperation对象并不会调用，它由一个start方法启动操作，但是注意如果直接调用start方法，则此操作会在主线程中调用，一般不会这么操作,而是添加到NSOperationQueue中
每个NSOperation可以设置依赖线程:
[blockOperation addDependency:lastBlockOperation];
主线程更新UI

//更新UI界面,此处调用了主线程队列的方法（mainQueue是UI主线程）
    [[NSOperationQueue mainQueue] addOperationWithBlock:^{
        [self updateImageWithData:data andIndex:i];
    }];

自定义NSOperation 参考
- 自定义串行NSOperation
  如果是使用start调用制定串行的NSOperation，是串行执行的，如果是吧自定义的串行NSOperation放到NSOperationQueue中则是并行的。
- 自定义并行NSOperation
  - start方法：该方法必须实现，
  - main:该方法可选，如果你在start方法中定义了你的任务，则这个方法就可以不实现，但通常为了代码逻辑清晰，通常会在该方法中定义自己的任务
  - isExecuting isFinished 主要作用是在线程状态改变时，产生适当的KVO通知
  - isConcurrent :必须覆盖并返回YES;
NSOperationQueue创建的其他队列同时具有串行、并发功能， maxConcurrentOperationCount，叫做最大并发数。
- maxConcurrentOperationCount=-1时默认是并发队列。
- maxConcurrentOperationCount>1时是并发队列。
- maxConcurrentOperationCount=1时是串行队列
如说有A、B两个操作，其中A执行完操作，B才能执行操作，那么就需要让B依赖于A。
[op2 addDependency:op1]; // 让op2 依赖于 op1，则先执行op1，在执行op2

GCD

在GDC中一个操作是多线程执行还是单线程执行取决于当前队列类型和执行方法，只有队列类型为并行队列并且使用异步方法执行时才能在多个线程中执行。
串行队列可以按顺序执行，并行队列的异步方法无法确定执行顺序。
UI界面的更新最好采用同步方法，其他操作采用异步方法。
dispatch_get_main_queue(),这个是主线程，是Serial Dispatch Queue
dispatch_sync dispatch_async的区别
dispatch_asycn函数的”asycn”意味着异步，就是将block追加到指定的queue中后，dispatch_asycn函数立即返回，不会等待执行的结果。

dispatch_queue_t queue = dispatch_queue_create("com.example.myQueue",  DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"block开始  queue:%@", [NSThread currentThread]);
        for(int i=0; i++ ; i<100) {
            
        }
        NSLog(@"block结束  queue:%@", [NSThread currentThread]);
    });
    NSLog(@"主线程  queue:%@", [NSThread currentThread]);

打印结果为：

block开始  queue:<NSThread: 0x60800006aa00>{number = 3, name = (null)}
主线程  queue:<NSThread: 0x604000067bc0>{number = 1, name = main}
block结束  queue:<NSThread: 0x60800006aa00>{number = 3, name = (null)}

dispatch_sycn函数意味着同步，也就是将block函数追加到queue中后，在block任务执行完之前，dispatch_sycn函数会一直等待。其实还是在主线程执行的。

dispatch_queue_t queue = dispatch_queue_create("com.example.myQueue",  DISPATCH_QUEUE_CONCURRENT);
    dispatch_sync(queue, ^{
        NSLog(@"block开始  queue:%@", [NSThread currentThread]);
        for(int i=0; i++ ; i<100) {}
        NSLog(@"block结束  queue:%@", [NSThread currentThread]);
    });
    NSLog(@"主线程  queue:%@", [NSThread currentThread]);

打印结果为：

block开始  queue:<NSThread: 0x6080000768c0>{number = 1, name = main}
block结束  queue:<NSThread: 0x6080000768c0>{number = 1, name = main}
主线程  queue:<NSThread: 0x6080000768c0>{number = 1, name = main}

串行队列 + 异步执行所有队列中的事务都是在一个子线程中执行

- (void)serialQueueaSync {
    NSLog(@"serialQueueSync begin-------%@", [NSThread currentThread]);
    dispatch_queue_t queue = dispatch_queue_create("serialQueueSync", DISPATCH_QUEUE_SERIAL);
    dispatch_async(queue, ^{
        for (int i=0; i<2; i++) {
            NSLog(@"1-------%@", [NSThread currentThread]);
        }});
    dispatch_async(queue, ^{
        for (int i=0; i<2; i++) {
            NSLog(@"2-------%@", [NSThread currentThread]);
        }});
    dispatch_async(queue, ^{
        for (int i=0; i<2; i++) {
            NSLog(@"3-------%@", [NSThread currentThread]);
        } });
    NSLog(@"serialQueueSync end-------%@", [NSThread currentThread]);
}

打印结果为：

serialQueueSync begin-------<NSThread: 0x60c0000628c0>{number = 1, name = main}
serialQueueSync end-------<NSThread: 0x60c0000628c0>{number = 1, name = main}
1-------<NSThread: 0x60c0002711c0>{number = 4, name = (null)}
1-------<NSThread: 0x60c0002711c0>{number = 4, name = (null)}
2-------<NSThread: 0x60c0002711c0>{number = 4, name = (null)}
2-------<NSThread: 0x60c0002711c0>{number = 4, name = (null)}
3-------<NSThread: 0x60c0002711c0>{number = 4, name = (null)}
3-------<NSThread: 0x60c0002711c0>{number = 4, name = (null)}

串行队列 + 同步执行所有队列中的事务都是主线程执行

- (void)serialQueueSync {
    NSLog(@"serialQueueSync begin-------%@", [NSThread currentThread]);
    dispatch_queue_t queue = dispatch_queue_create("serialQueueSync", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(queue, ^{
        for (int i=0; i<2; i++) {
            NSLog(@"1-------%@", [NSThread currentThread]);
        }});
    dispatch_sync(queue, ^{
        for (int i=0; i<2; i++) {
            NSLog(@"2-------%@", [NSThread currentThread]);
        } });
    dispatch_sync(queue, ^{
        for (int i=0; i<2; i++) {
            NSLog(@"3-------%@", [NSThread currentThread]);
        } });
    NSLog(@"serialQueueSync end-------%@", [NSThread currentThread]);
}

打印结果：

begin-------<NSThread: 0x608000060540>{number = 1, name = main}
1-------<NSThread: 0x608000060540>{number = 1, name = main}
1-------<NSThread: 0x608000060540>{number = 1, name = main}
2-------<NSThread: 0x608000060540>{number = 1, name = main}
2-------<NSThread: 0x608000060540>{number = 1, name = main}
3-------<NSThread: 0x608000060540>{number = 1, name = main}
3-------<NSThread: 0x608000060540>{number = 1, name = main}
 serialQueueSync end-------<NSThread: 0x608000060540>{number = 1, name = main}

死锁
在串行队列中执行同步操作会发生死锁，例如在主线程中执行如下代码，会在打印完第一个log后，死锁。

    NSLog(@"hello world0");
    //因为是同步执行，所以
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"hello world1");
    });
    NSLog(@"hello world2");

同理，如下代码也会发生死锁，如下代码只会影响serialQueue内部发生死锁，不会阻塞主线程。

dispatch_queue_t serialQueue = dispatch_queue_create("com.example.gcd.serialQueue", NULL);
    NSLog(@"main begin");
    dispatch_async(serialQueue, ^{
        NSLog(@"外层begin");
        dispatch_sync(serialQueue, ^{
            NSLog(@"hello world");
        });
        NSLog(@"外层end");
        
    });
    NSLog(@"main end");

运行结果：

main begin
main end
外层begin

dispatch group 经常会碰到这种情况，想要在加入到Dispatch Queue中的多个block任务都执行完后取执行其他任务，如果使用的是串行队列，只要将所有的block任务加入到串行队列并在最后追加其他任务即可；如果使用的是并行队列或者有多个DIspatch Queue时，可以使用Dispatch Group。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, queue, ^{
        NSLog(@"block1 begin");
        for(int i=0; i<1000; i++){}
        NSLog(@"block1 end");
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"block2 begin");
        for(int i=0; i<1000; i++){}
        NSLog(@"block1 end");
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"block3 begin");
        for(int i=0; i<1000; i++){}
        NSLog(@"block3 end");
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue()/*queue*/, ^{
        NSLog(@"done");
    });
    NSLog(@"testGroup END");

打印结果

block1 begin
testGroup END
block2 begin
block3 begin
block1 end
block3 end
block1 end
done

dispatch_group_notify(dispatch_group_t group, <#dispatch_queue_t queue#>, <#^(void)block#>)是等到之前与group联系过的block执行完后会把这个block提交到queue中。
无论向什么样的Dispatch Queue中追加任务，使用Dispatch Group都可以监视这些任务的结束。

dispatch_barrier_asycn
dispatch_barrier_asycn会等到追加到queue中的block任务执行完后，再将指定的block任务追加到queue中，然后等到指定的block执行完后，queue才恢复一般的动作，之后追加的block任务才开始执行。

NSMutableArray * array = @[@"1"].mutableCopy;
    dispatch_queue_t queue = dispatch_queue_create("com.example.gcd.ForBarrier", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"block1 = %@", array[0]);
        //读取处理block1
    });
    dispatch_async(queue, ^{
        NSLog(@"block2 = %@", array[0]);
        
        //读取处理block2
    });
    dispatch_async(queue, ^{
        sleep(2);
        NSLog(@"block3 = %@", array[0]);
        //读取处理block3
    });
    dispatch_barrier_async(queue, ^{
        NSLog(@"dispatch barrier begin");
        [array replaceObjectAtIndex:0 withObject:@"2"];
        NSLog(@"dispatch barrier end");
    });
    dispatch_async(queue, ^{
        NSLog(@"block4 = %@", array[0]);
    });

dispatch_barrier_async会等上面的block1, bolock2，block3 执行完成后，再执行自己的block，然后才是执行block4，运行结果:

block2 = 1
block1 = 1
block3 = 1
dispatch barrier begin
dispatch barrier end
block4 = 2

dispatch_after
dispatch_after函数并不是在指定的时间后执行block，而是在指定的时间将block添加到queue中。

线程同步

@synchronized代码块
使用@synchronized解决线程同步问题相比较NSLock要简单一些，日常开发中也更推荐使用此方法。首先选择一个对象作为同步对象（如果成员变量或者属性为同步对象，一般使用self），然后将”加锁代码”（争夺资源的读取、修改代码）放到代码块中。@synchronized中的代码执行时先检查同步对象是否被另一个线程占用，如果占用该线程就会处于等待状态，直到同步对象被释放。
信号量机制dispatch_semaphore 浅谈GCD中的信号量，条件锁NSCondition
- 转换异步block为同步方式运行
互斥锁 NSLock、递归锁NSRecursiveLock:同一线程可多次加锁，不会造成死锁.
自旋锁 OSSpinLock。自旋锁与互斥锁有点类似，只是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁，"自旋"一词就是因此而得名。由于自旋锁使用者一般保持锁时间非常短，因此选择自旋而不是睡眠是非常必要的，自旋锁的效率远高于互斥锁。不再安全的 OSSpinLock
noatomic 只对set get方法起作用，
pthread_mutex(YYCache)

除了 OSSpinLock 外，dispatch_semaphore 和 pthread_mutex 性能是最高的。有消息称，苹果在新系统中已经优化了 pthread_mutex 的性能，所以它看上去和 OSSpinLock 差距并没有那么大了。

参考文档

GCD常用方法总结
 起底多线程同步锁(iOS)
NSRecursiveLock递归锁的使用
 iOS多线程-各种线程锁的简单介绍

iOS多线程

NSOperation

GCD

线程同步

参考文档

猜你喜欢

热点阅读