iOS多线程必备知识点-持续更新

作者: vincentgemini | 来源:发表于2018-04-06 23:16 被阅读0次

NSThread

1、线程创建方法：

// 手动[NSThread start]启动线程，可以拿到线程对象进行详细设置。
[[NSThread alloc] initWithTarget:self selector:@selector(threadRun) object:nil];

// 手动[NSThread start]启动线程，可以拿到线程对象进行详细设置。
[[NSThread alloc] initWithBlock:^{
    
}];

// 自动启动线程，无法进行更详细设置。
[NSThread detachNewThreadSelector:@selector(threadRun) toTarget:self withObject:nil];

2、线程退出方法：

[NSThread exit];

也可通过停止runloop来退出线程，具体操作参考下面的标准自定义线程。

3、线程间通讯方法：

[self performSelectorOnMainThread:@selector(onDoSomething) withObject:nil waitUntilDone:NO];

[self performSelector:@selector(onDoSomething) onThread:thread withObject:nil waitUntilDone:NO];

4、标准自定义线程：

@interface ThreadedComponent : NSObject
{
    NSThread *_thread;
    NSCondition *_condition;
}

- (void)start;
- (void)stop;

@end

- (instancetype)init
{
    if ((self = [super init])) {
        _condition = [[NSCondition alloc] init];
    }
    return self;
}

- (void)dealloc
{
    [self stop];
}

- (void)start
{
    if (_thread) {
        return;
    }
    _thread = [[NSThread alloc] initWithTarget:self selector:@selector(threadProc:) object:nil];

    [_condition lock];
    [_thread start];
    [_condition wait];
    [_condition unlock];

    NSLog(@"thread should have started");
}

- (void)stop
{
    if (!_thread) {
        return;
    }

    [_condition lock];
    [self performSelector:@selector(_stop) onThread:_thread withObject:nil waitUntilDone:NO];
    [_condition wait];
    [_condition unlock];
    _thread = nil;

    NSLog(@"thread should have stopped");
}

#pragma mark Private Helpers
static void DoNothingRunLoopCallback(void *info)
{
}

- (void)threadProc:(id)object
{
    @autoreleasepool {
        CFRunLoopSourceContext context = {0};
        context.perform = DoNothingRunLoopCallback;
    
        CFRunLoopSourceRef source = CFRunLoopSourceCreate(NULL, 0, &context);
        CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
    
        [_condition lock];
        [_condition signal];
        NSLog(@"thread has started");
        [_condition unlock];
    
        // Keep processing events until the runloop is stopped.
        CFRunLoopRun();
    
        CFRunLoopRemoveSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
        CFRelease(source);
    
        [_condition lock];
        [_condition signal];
        NSLog(@"thread has stopped");
        [_condition unlock];
    }
}

- (void)_stop
{
    CFRunLoopStop(CFRunLoopGetCurrent());
}

GCD：

1、创建队列方法：

串行队列：

dispatch_queue_t queue = dispatch_queue_create("队列名称", DISPATCH_QUEUE_SERIAL);

并行队列：

dispatch_queue_t queue = dispatch_queue_create("队列名称", DISPATCH_QUEUE_CONCURRENT);

2、同步执行：

dispatch_sync(queue, ^{
    //耗时任务
});

3、异步执行：

dispatch_async(queue, ^{
    //耗时任务
});

4、需要注意不要在主队列中执行主队列同步操作，会造成卡死。

5、延迟执行：

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // 2秒后异步执行这里的代码...
    //耗时任务
});

6、重复执行：可以采用并行队列和串行队列执行，如果是并行队列，需要注意资源争抢问题。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

dispatch_apply(6, queue, ^(size_t index) {
    NSLog(@"%zd------%@",index, [NSThread currentThread]);
});

7、通过Group控制依赖

dispatch_group_t group =  dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 执行1个耗时的异步操作
    sleep(1);
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    // 执行1个耗时的异步操作
   sleep(1);
});
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
//dispatch_group_notify(group, dispatch_get_main_queue(), ^{
//   // 等前面的异步操作都执行完毕后，回到主线程...
//   NSLog(@"onGroup 3");
//});

此处需要注意dispatch_group_wait和dispatch_group_notify却别和使用场景。

8、切换队列，将队列中的任务指定到另外队列上执行。

//1.创建目标队列
//dispatch_queue_t targetQueue = dispatch_queue_create("test.target.queue", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t targetQueue = dispatch_queue_create("test.target.queue", DISPATCH_QUEUE_CONCURRENT);

//2.创建3个串行队列
dispatch_queue_t queue1 = dispatch_queue_create("test.1", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t queue2 = dispatch_queue_create("test.2", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t queue3 = dispatch_queue_create("test.3", DISPATCH_QUEUE_SERIAL);

//3.将3个串行队列分别添加到目标队列
dispatch_set_target_queue(queue1, targetQueue);
dispatch_set_target_queue(queue2, targetQueue);
dispatch_set_target_queue(queue3, targetQueue);

dispatch_async(queue1, ^{
    NSLog(@"1 in");
    [NSThread sleepForTimeInterval:3.f];
    NSLog(@"1 out");
});

dispatch_async(queue1, ^{
    NSLog(@"1.1");
});

dispatch_async(queue2, ^{
    NSLog(@"2 in");
    [NSThread sleepForTimeInterval:2.f];
    NSLog(@"2 out");
});

dispatch_async(queue2, ^{
    NSLog(@"2.1");
});

dispatch_async(queue3, ^{
    NSLog(@"3 in");
    [NSThread sleepForTimeInterval:1.f];
    NSLog(@"3 out");
});

dispatch_async(queue3, ^{
    NSLog(@"3.1");
});

9、使用信号量控制任务依赖

dispatch_queue_t queue = dispatch_queue_create("blockGCD", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(queue, ^{

    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    dispatch_async(queue, ^{
   
        NSLog(@"step 0");
    
        sleep(2);
    
        dispatch_semaphore_signal(semaphore);
    
        NSLog(@"step 1");
    });

    NSLog(@"step 2");
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

    dispatch_async(queue, ^{
    
        NSLog(@"step 3");
    
    });

    NSLog(@"step 4");
});

10、使用栅栏控制任务依赖

dispatch_queue_t queue = dispatch_queue_create("gcd.test", DISPATCH_QUEUE_CONCURRENT);

NSLog(@"onBarrierAsyncConcurrent  11");

dispatch_async(queue, ^{

    sleep(1);
    NSLog(@"onBarrierAsyncConcurrent  1");
});

NSLog(@"onBarrierAsyncConcurrent  22");

dispatch_async(queue, ^{

    NSLog(@"onBarrierAsyncConcurrent  2");
});

NSLog(@"onBarrierAsyncConcurrent  33");

dispatch_barrier_async(queue, ^{

    sleep(1);
    NSLog(@"onBarrierAsyncConcurrent  3");
});

NSLog(@"onBarrierAsyncConcurrent  44");

dispatch_async(queue, ^{

    NSLog(@"onBarrierAsyncConcurrent  4");
});

NSLog(@"onBarrierAsyncConcurrent  55");

dispatch_async(queue, ^{

    NSLog(@"onBarrierAsyncConcurrent  5");
});

11、如何同步多个异步操作：直接上代码

-(void)onGroupOption
{
    NSLog(@"onGroupOption Begin");
    [self function:0];
    [self function:1];
    NSLog(@"onGroupOption End");
}
-(void)function:(NSInteger)num
{
    if (!_queue) {
        _queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    }
    if (!_group) {
        _group = dispatch_group_create();
    }
    if (!_sem) {
        _sem = dispatch_semaphore_create(1);
    }
    dispatch_async(_queue, ^{
        dispatch_semaphore_wait(_sem, DISPATCH_TIME_FOREVER);
        //dispatch_group_enter(_group);
    
        [self onFuncWithID:num complete:^(BOOL success) {
            dispatch_semaphore_signal(_sem);
            //dispatch_group_leave(_group);
        }];
    });
}
-(void)onFuncWithID:(NSInteger)ID complete:(void(^)(BOOL success))handler
{
    dispatch_async(_queue, ^(void){
        NSLog(@"onFuncWithID = %ld", (long)ID);
        // do actual processing here
        for (int i = 0; i<10; i++) {
            //NSLog(@"%d", i);
            sleep(0.5);
        }
        dispatch_async(_queue, ^(void){
            NSLog(@"可以处理下一个函数了");
            handler(YES);
        });
    });
}

NSOperationQueue：

不能直接实例化NSOperation，只能实例化子类：NSInvocationOperation和NSBlockOperation。
NSInvocationOperation和NSBlockOperation直接start时，NSInvocationOperation和NSBlockOperation在主线程执行，但addExecutionBlock的任务在子线程执行，一般一次addExecutionBlock就会起一个子线程执行，创建多少个线程，取决于系统资源情况。
NSBlockOperation的addExecutionBlock需要在调用start前执行，否则会出现异常，提示：blocks cannot be added after the operation has started executing or finished。
当NSInvocationOperation和NSBlockOperation调用start后，不能将其再addOperation到队列，否则会出现异常，提示：operation is finished and cannot be enqueued。
NSOperationQueue是异步队列，默认并发数为无穷，可以手动修改并发数量。当并发数设置为1时为串行队列，但其队列中的任务未必会在同一个线程中执行，串行之能保证同一时刻只有一个任务在执行。
任务加入到NSOperationQueue后会自动执行，不用调用start。
可以取消NSOperationQueue未执行的任务，可以暂停NSOperationQueue未执行的任务，可以恢复NSOperationQueue暂停的任务，任务一旦执行，将不能取消和暂停。
可以设置任务之间的依赖来控制任务的执行顺序。

持续更新。。。

网友评论

程序员

本文标题：iOS多线程必备知识点-持续更新

本文链接：https://www.haomeiwen.com/subject/jvjthftx.html

延伸阅读

深度阅读

您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！