多线程

解决方案对比

方案

简介

语言

线程生命周期

使用频率

pthread

一套通用的多线程API 适用unix/linux/Windows等跨平台、可移植使用难度大

手动

几乎不用

NSThread

面向对象简单易用，可直接操作线程对象

手动

偶尔使用

GCD

旨在替代NSThread等线程技术充分利用设备的多核

自动

经常使用

NSOperation

底层是GCD 比GCD多一些简单实用的功能更加面向对象

自动

经常使用

Pthreads

POSIX线程（POSIX threads），简称Pthreads，是线程的POSIX标准。该标准定义了创建和操纵线程的一整套API。在类Unix操作系统（Unix、Linux、Mac OS X等）中，都使用Pthreads作为操作系统的线程。

通用多线程API，基于C语言框架，高移植性，iOS中基本不用

NSThread

经苹果封装面向对象的线程操作类，需要我们手动管理它的生命周期.

// 创建线程
NSThread *thread = [[NSThread alloc] initWithBlock:threadBlock];
//启动线程
[thread start];

// 隐式创建并启动线程
[self performSelectorInBackground:@selector(run) withObject:nil];

类方法&属性

//当前线程，number=1，name=main表示主线程
@property (class, readonly, strong) NSThread *currentThread;

//休眠2秒
[NSThread sleepForTimeInterval:2];

//休眠到指定时间，2秒后
[NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:2.0]];

//退出线程
[NSThread exit];

//判断当前线程是否为主线程
[NSThread isMainThread];

//判断当前线程是否是多线程
[NSThread isMultiThreaded];

//主线程的对象
[NSThread mainThread];

示例方法&属性

详见<Foundation/NSThread.h>

GCD

在主队列中执行同步任务会造成*DeadLock*

执行方式

并行队列

串行队列

主队列

异步执行

开启多个线程，任务同时执行

开启一个新线程，任务按顺序执行

在主线程按顺序执行任务

同步执行

不开启线程，按顺序在主线程执行任务

在主线程按顺序执行任务

DealLock

主队列

dispatch_get_main_queue();

串行队列

dispatch_queue_create("queue_serial", DISPATCH_QUEUE_SERIAL)

并行队列

dispatch_queue_create("queue_concurrent", DISPATCH_QUEUE_CONCURRENT)

全局并行队列

dispatch_get_global_queue(0, 0);

栅栏

当任务需要异步进行，但是这些任务需要分成两组来执行，第一组完成之后才能进行第二组的操作。这时候就用了到GCD的栅栏方法dispatch_barrier_async
dispatch_barrier_sync会在主线程执行，后续任务需要等待
在使用栅栏函数时.使用自定义队列才有意义,如果用的是串行队列或者系统提供的全局并发队列,这个栅栏函数的作用等同于一个同步函数的作用

dispatch_queue_t queue3 = dispatch_queue_create("queue3", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue3, ^{
    for (int i=0; i<3; i++) {
        LogDebug(@"栅栏并发异步1-%d %@", i, [NSThread currentThread]);
    }
});
dispatch_async(queue3, ^{
    for (int i=0; i<3; i++) {
        LogDebug(@"栅栏并发异步2-%d %@", i, [NSThread currentThread]);
    }
});

dispatch_barrier_async(queue3, ^{
    LogDebug(@"---------barrier---------%@", [NSThread currentThread]);
});

dispatch_async(queue3, ^{
    for (int i=0; i<3; i++) {
        LogDebug(@"栅栏并发异步3-%d %@", i, [NSThread currentThread]);
    }
});
dispatch_async(queue3, ^{
    for (int i=0; i<3; i++) {
        LogDebug(@"栅栏并发异步4-%d %@", i, [NSThread currentThread]);
    }
});

dispatch_after（延时执行）

dispatch_after

dispatch_apply（快速迭代）

dispatch_apply按指定的次数将指定的block追加到指定的队列中，并等待全部处理执行结束，好处是可以重复执行某项操作并复用我们的block了
第一个参数为重复次数；第二个参数为追加对象的Dispatch Queue；第三个参数为追加的操作，追加的Block中带有参数，这是为了按第一个参数重复追加Block并区分各个Block而使用。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

//在全局队列queue上执行十次输出操作
dispatch_apply(10, queue, ^(size_t index) {
    LogDebug(@"%zu", index);
});

LogDebug(@"done!");

队列分组

dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        LogDebug(@"队列分组异步1 %@", [NSThread currentThread]);
    });
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        LogDebug(@"队列分组异步2 %@", [NSThread currentThread]);
    });
    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        LogDebug(@"队列分组异步3 %@", [NSThread currentThread]);
    });

    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        LogDebug(@"队列分组任务全部执行完成 %@", [NSThread currentThread]);
    });

NSOperation

基于GCD更高级的封装，更加面向对象
支持添加依赖任务

// 示例
let oq = OperationQueue()

let o1 = BlockOperation(block: {
    print("1、doing \(Thread.current)")
})

let o2 = BlockOperation(block: {
    print("2、doing \(Thread.current)")
})

let o3 = BlockOperation(block: {
    print("3、doing \(Thread.current)")
})

let o4 = BlockOperation(block: {
    print("4、doing \(Thread.current)")
})

let o5 = BlockOperation {
    print("5、finished \(Thread.current)")
}

o5.addDependency(o1)
o5.addDependency(o2)
o5.addDependency(o3)
o5.addDependency(o4)

/*
    不使用OperationQueue

    o2.addDependency(o3)

    o1.start()
    o3.start()
    o2.start()
    o4.start()
    o5.start()

    */

o2.addDependency(o3)

oq.addOperation(o5)
oq.addOperation(o2)
oq.addOperation(o1)
oq.addOperation(o4)
oq.addOperation(o3)

print("current \(Thread.current)")

RunLoop

是一种“闲”等待的循环，有事件的时候去寻找handler处理，没有事件时进入休眠。

下图中展现了 Runloop 在线程中的作用：从 input source 和 timer source 接受事件，然后在线程中处理事件。

每个线程对应一个Runloop，App启动时主线程的RunLoop完成启动

Input Source 和 Timer Source

其中 Input Source 又可以分为三类

Port-Based Sources，系统底层的 Port 事件，例如 CFSocketRef ，在应用层基本用不到
Custom Input Sources，用户手动创建的 Source
Cocoa Perform Selector Sources， Cocoa 提供的 performSelector 系列方法，也是一种事件源

Timer Source

- 明显就是指计时器事件

Runloop Observer

Runloop 通过监控 Source 来决定有没有任务要做，除此之外，我们还可以用 Runloop Observer 来监控 Runloop 本身的状态。 Runloop Observer 可以监控下面的 runloop 事件：

The entrance to the run loop.
When the run loop is about to process a timer.
When the run loop is about to process an input source.
When the run loop is about to go to sleep.
When the run loop has woken up, but before it has processed the event that woke it up.
The exit from the run loop.

Runloop Mode

在监视与被监视中，Runloop 要处理的事情还挺复杂的。为了让 Runloop 能专心处理自己关心的那部分事情，引入了 Runloop Mode 概念。

如图所示，Runloop Mode 实际上是 Source，Timer 和 Observer 的集合，不同的 Mode 把不同组的 Source，Timer 和 Observer 隔绝开来。Runloop 在某个时刻只能跑在一个 Mode 下，处理这一个 Mode 当中的 Source，Timer 和 Observer。

苹果文档中提到的 Mode 有五个，分别是：

NSDefaultRunLoopMode
~~NSConnectionReplyMode~~
~~NSModalPanelRunLoopMode~~
~~NSEventTrackingRunLoopMode~~
NSRunLoopCommonModes

iOS 中公开暴露出来的只有 NSDefaultRunLoopMode 和 NSRunLoopCommonModes。 NSRunLoopCommonModes 实际上是一个 Mode 的集合，默认包括 NSDefaultRunLoopMode 和 NSEventTrackingRunLoopMode。

与 Runloop 相关的坑

日常开发中，与 runLoop 接触得最近可能就是通过 NSTimer 了。一个 Timer 一次只能加入到一个 RunLoop 中。我们日常使用的时候，通常就是加入到当前的 runLoop 的 default mode 中，而 ScrollView 在用户滑动时，主线程 RunLoop 会转到 UITrackingRunLoopMode 。而这个时候， Timer 就不会运行。

有如下两种解决方案：

第一种: 设置 RunLoop Mode，例如 NSTimer,我们指定它运行于 NSRunLoopCommonModes ，这是一个 Mode 的集合。注册到这个 Mode 下后，无论当前 runLoop 运行哪个 mode ，事件都能得到执行。
第二种: 另一种解决 Timer 的方法是，我们在另外一个线程执行和处理 Timer 事件，然后在主线程更新 UI。

Previous琐事 NextARC

Last updated 4 years ago

Was this helpful?