iOS开发探索多线程GCD队列示例详解

目录

• 引言
• 进程与线程
• 1.进程的定义
• 2.线程的定义
• 3、 进程和线程的关系
• 4、 多线程
• 5、 时间片
• 6、 线程池
• GCD
• 1、任务
• 2、队列
• 3、死锁
• 总结

引言

在iOS开发过程中，绕不开网络请求、下载图片之类的耗时操作，这些操作放在主线程中处理会造成卡顿现象，所以我们都是放在子线程进行处理，处理完成后再返回到主线程进行展示。

多线程贯穿了我们整个的开发过程，iOS的多线程操作有NSThread、GCD、NSOperation，其中我们最常用的就是GCD。

进程与线程

在了解GCD之前我们先来了解一下进程和线程，及他们的联系与区别

1.进程的定义

• 进程是指在系统中正在运行的一个应用程序
• 每个进程之间是独立的，每个进程均运行在其专用的且受保护的内存空间内
• 进程间通信一般使用URL Scheme、UIPasteboard、Keychain、UIActivityViewController等

2.线程的定义

• 线程是进程的基本执行单元，一个进程的所有任务都在线程中执行
• 进程想要执行任务，必须得有线程，进程至少要有一条线程
• 程序启动会默认开启一条线程，这条线程被成为主线程
• 线程之间的通信一般使用performSelector

3、 进程和线程的关系

• 1.线程是进程的执行单元，进程的所有任务都在线程中执行
• 2.线程是 CPU 分配资源和调度的最小单位
• 3.手机中一个程序对应一个进程,一个进程中可有多个线程,但至少要有一条线程
• 4.同一个进程内的线程共享进程资源

4、 多线程

同一时间，CPU只能处理1条线程，只有1条线程在执行。多线程并发执行，其实是CPU快速地在多条线程之间调度（切换）。如果CPU调度线程的时间足够快，就造成了多线程并发执行的假象

如果线程非常非常多，CPU会在N多线程之间调度，消耗大量的CPU资源，每条线程被调度执行的频次会降低（线程的执行效率降低）

多线程的优点:

• 1.能适当提高程序的执行效率；
• 2.能适当提高资源利用率（CPU、内存利用率） 3.线程上的任务执行完成后，线程会自动销毁

多线程的缺点:

• 1.开启线程需要占用一定的内存空间（默认情况下，主线程占用1M，子线程占用512KB），如果开启大量的线程，会占用大量的内存空间，降低程序的性能，开启线程大概需要90微秒的时间
• 2.线程越多，每个线程被调度的次数就越低，线程的执行效率就越低，CPU在调度线程上的开销越大
• 3.程序设计更加复杂，比如线程之间的通信、多线程的数据共享

多线程的生命周期是：新建 - 就绪 - 运行 - 阻塞 - 死亡

• 新建：实例化线程对象
• 就绪：向线程对象发送start消息，线程对象被加入可调度线程池等待CPU调度。
• 运行：CPU 负责调度可调度线程池中线程的执行。线程执行完成之前，状态可能会在就绪和运行之间来回切换。就绪和运行之间的状态变化由CPU负责，程序员不能干预。
• 阻塞：当满足某个预定条件时，可以使用休眠或锁，阻塞线程执行。sleepForTimeInterval（休眠指定时长），sleepUntilDate（休眠到指定日期），@synchronized(self)：（互斥锁）。
• 死亡：正常死亡，线程执行完毕。非正常死亡，当满足某个条件后，在线程内部中止执行/在主线程中止线程对象

5、 时间片

时间片：CPU在多个任务直接进行快速的切换，这个时间间隔就是时间片
设备并发执行的数量是有限的，使用[NSProcessInfo processInfo].activeProcessorCount可以查看当前设备能够支持线程的最大并发数量，比如说最大并发数是8，代表8核cpu，如果同时开启了10个线程，则会有CPU通过时间片轮转的方式让某一个或者某两个线程分别执行一段时间。

6、 线程池

GCD在内部维护了一个线程池，目的是为了复用线程，需要开启线程时，其会先在线程池中查询已开辟的空闲线程缓存，达到节省内存空间和时间的目的。

• 核心线程是否都在执行任务 - 没有 - 创建新的工作线程去执行
• 线程池工作队列是否饱和 - 没有 - 将任务存储在工作队列
• 线程池的线程都处于执行状态 - 没有 - 安排线程去执行
• 交给饱和策略去处理 GCD的线程池中缓存64条线程,就是同时可以有64条线程正在执行，最大并发执行的线程根据CPU决定。

GCD

GCD全称是Grand Central Dispatch，它是纯 C 语言，并且提供了非常多强大的函数

GCD的优势：

• GCD 是苹果公司为多核的并行运算提出的解决方案
• GCD 会自动利用更多的CPU内核（比如双核、四核）
• GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
• 程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码 GCD的核心——将任务添加到队列，并且指定执行任务的函数

1、任务

就是执行操作的意思，也就是在线程中执行的那段代码。在 GCD 中是放在 block 中的。执行任务有两种方式：同步执行（sync）和异步执行（async）

• 同步(Sync) ：同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行，即会阻塞线程。只能在当前线程中执行任务(是当前线程，不一定是主线程)，不具备开启新线程的能力。
• 异步(Async) ：线程会立即返回，无需等待就会继续执行下面的任务，不阻塞当前线程。可以在新的线程中执行任务，具备开启新线程的能力(并不一定开启新线程)。如果不是添加到主队列上，异步会在子线程中执行任务

2、队列

队列（Dispatch Queue）：这里的队列指执行任务的等待队列，即用来存放任务的队列。队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。队列的作用就是存储任务，和线程没有任何关系。每读取一个任务，则从队列中释放一个任务
在 GCD 中有两种队列：串行队列和并发队列。两者都符合 FIFO（先进先出）的原则。两者的主要区别是：执行顺序不同，以及开启线程数不同。

• 串行队列（Serial Dispatch Queue） ：
  同一时间内，队列中只能执行一个任务，只有当前的任务执行完成之后，才能执行下一个任务。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）。主队列是主线程上的一个串行队列,是系统自动为我们创建的
• 并发队列（Concurrent Dispatch Queue） ：
  同时允许多个任务并发执行。（可以开启多个线程，并且同时执行任务）。并发队列的并发功能只有在异步（dispatch_async）函数下才有效

3、死锁

在串行队列中添加任务的block中含有另一个向同一队列添加的同步任务就会发生死锁，因为同步任务立即执行，队列需要遵守FIFO（先进先出）的原则，串行队列需要等待前一个任务执行结束才会执行下一个任务，导致互相等待造成死锁。

接下来我们从源码中了解一下GCD的串行队列和并发队列都做了什么，有什么区别。

dispatch_queue_t main = dispatch_get_main_queue(); //主队列
dispatch_queue_t global = dispatch_get_global_queue(0, 0); //全局队列
dispatch_queue_t serial = dispatch_queue_create("WT", DISPATCH_QUEUE_SERIAL); // 串行队列
dispatch_queue_t concurrent = dispatch_queue_create("WT", DISPATCH_QUEUE_CONCURRENT); //并发队列
// 主队列源码
dispatch_get_main_queue(void) {
    return DISPATCH_GLOBAL_OBJECT(dispatch_queue_main_t, _dispatch_main_q);
}
struct dispatch_queue_static_s _dispatch_main_q = {
    DISPATCH_GLOBAL_OBJECT_HEADER(queue_main),
    #if !DISPATCH_USE_RESOLVERS
    .do_targetq = _dispatch_get_default_queue(true),
    #endif
    .dq_state = DISPATCH_QUEUE_STATE_INIT_VALUE(1) |
    DISPATCH_QUEUE_ROLE_BASE_ANON,
    .dq_label = "com.apple.main-thread",
    .dq_atomic_flags = DQF_THREAD_BOUND | DQF_WIDTH(1),
    .dq_serialnum = 1,
};
// 全局队列源码
dispatch_get_global_queue(intptr_t priority, uintptr_t flags) {
    dispatch_qos_t qos = _dispatch_qos_from_queue_priority(priority);
    ……
    return _dispatch_get_root_queue(qos, flags & DISPATCH_QUEUE_OVERCOMMIT);
}
#define DISPATCH_QUEUE_WIDTH_FULL 0x1000ull
#define DISPATCH_QUEUE_WIDTH_POOL (DISPATCH_QUEUE_WIDTH_FULL - 1)
struct dispatch_queue_global_s _dispatch_root_queues[] = {
    #define _DISPATCH_ROOT_QUEUE_IDX(n, flags) \
    ((flags & DISPATCH_PRIORITY_FLAG_OVERCOMMIT) ? \
    DISPATCH_ROOT_QUEUE_IDX_##n##_QOS_OVERCOMMIT : \
    DISPATCH_ROOT_QUEUE_IDX_##n##_QOS)
    #define _DISPATCH_ROOT_QUEUE_ENTRY(n, flags, ...) \
    [_DISPATCH_ROOT_QUEUE_IDX(n, flags)] = { \
    DISPATCH_GLOBAL_OBJECT_HEADER(queue_global), \
    .dq_state = DISPATCH_ROOT_QUEUE_STATE_INIT_VALUE, \
    .do_ctxt = _dispatch_root_queue_ctxt(_DISPATCH_ROOT_QUEUE_IDX(n, flags)), \
    .dq_atomic_flags = DQF_WIDTH(DISPATCH_QUEUE_WIDTH_POOL), \
    .dq_priority = flags | ((flags & DISPATCH_PRIORITY_FLAG_FALLBACK) ? \
    _dispatch_priority_make_fallback(DISPATCH_QOS_##n) : \
    _dispatch_priority_make(DISPATCH_QOS_##n, 0)), \
    __VA_ARGS__ \
    }
    _DISPATCH_ROOT_QUEUE_ENTRY(MAINTENANCE, 0,
        .dq_label = "com.apple.root.maintenance-qos",
        .dq_serialnum = 4,
    ),
    ...省略部分...
    _DISPATCH_ROOT_QUEUE_ENTRY(USER_INTERACTIVE, DISPATCH_PRIORITY_FLAG_OVERCOMMIT,
        .dq_label = "com.apple.root.user-interactive-qos.overcommit",
        .dq_serialnum = 15,
    ),
};
// 串行队列源码
#define DISPATCH_QUEUE_SERIAL NULL
// 并发队列源码
#define DISPATCH_QUEUE_CONCURRENT DISPATCH_GLOBAL_OBJECT(dispatch_queue_attr_t,  _dispatch_queue_attr_concurrent)
dispatch_queue_t dispatch_queue_create(const char *label, dispatch_queue_attr_t attr) {
    return _dispatch_lane_create_with_target(label, attr, DISPATCH_TARGET_QUEUE_DEFAULT, true);
}
#if OS_OBJECT_USE_OBJC
#define DISPATCH_GLOBAL_OBJECT(type, object) ((OS_OBJECT_BRIDGE type)&(object))

#define DISPATCH_QUEUE_WIDTH_MAX  (DISPATCH_QUEUE_WIDTH_FULL - 2)
static dispatch_queue_t _dispatch_lane_create_with_target(const char *label, dispatch_queue_attr_t dqa, dispatch_queue_t tq, bool legacy) {
    // 串行队列dqai为{}
    dispatch_queue_attr_info_t dqai = _dispatch_queue_attr_to_info(dqa);
    ...省略部分 - 根据dqai规范化参数...
    dispatch_lane_t dq = _dispatch_object_alloc(vtable, sizeof(struct dispatch_lane_s));
    // 初始化队列 并发队列 DISPATCH_QUEUE_WIDTH_MAX  串行队列 1
    _dispatch_queue_init(dq, dqf, dqai.dqai_concurrent ? DISPATCH_QUEUE_WIDTH_MAX : 1, DISPATCH_QUEUE_ROLE_INNER | (dqai.dqai_inactive ? DISPATCH_QUEUE_INACTIVE : 0));
    ...省略部分...
    return _dispatch_trace_queue_create(dq)._dq;
}
_dispatch_queue_attr_to_info(dispatch_queue_attr_t dqa) {
    dispatch_queue_attr_info_t dqai = { };
    // 串行队列直接返回 {}
    if (!dqa) return dqai; //
    #if DISPATCH_VARIANT_STATIC
        if (dqa == &_dispatch_queue_attr_concurrent) { // 并发队列
            dqai.dqai_concurrent = true;
            return dqai;
        }
    #endif
    ...一系列操作...
    return dqai;
}
static inline dispatch_queue_class_t _dispatch_queue_init(dispatch_queue_class_t dqu, dispatch_queue_flags_t dqf, uint16_t width, uint64_t initial_state_bits) {
    uint64_t dq_state = DISPATCH_QUEUE_STATE_INIT_VALUE(width);
    dispatch_queue_t dq = dqu._dq;
    dispatch_assert((initial_state_bits & ~(DISPATCH_QUEUE_ROLE_MASK |
    DISPATCH_QUEUE_INACTIVE)) == 0);
    if (initial_state_bits & DISPATCH_QUEUE_INACTIVE) {
        dq->do_ref_cnt += 2; // rdar://8181908 see _dispatch_lane_resume
        if (dx_metatype(dq) == _DISPATCH_SOURCE_TYPE) {
            dq->do_ref_cnt++; // released when DSF_DELETED is set
        }
    }
    dq_state |= initial_state_bits;
    dq->do_next = DISPATCH_OBJECT_LISTLESS;
    dqf |= DQF_WIDTH(width); // 串行队列DQF_WIDTH(1) -- 主队列  -- 串行队列
    os_atomic_store2o(dq, dq_atomic_flags, dqf, relaxed);
    dq->dq_state = dq_state;
    dq->dq_serialnum =
    os_atomic_inc_orig(&_dispatch_queue_serial_numbers, relaxed);
    return dqu;
}

我们可以看到初始化的时候，主队列及串行队列初始化队列都是DQF_WIDTH(1)，全局并发队列DQF_WIDTH(0x1000ull - 1 = 15),并发队列DQF_WIDTH(0x1000ull - 2 = 14);

主队列的number = 1，全局队列number = 4-15，其他number也可以在Dispatch Source/init.c文件里查找到。

总结

串行队列就类似单行道，并发队列相当于多车道，虽然都是FIFO的数据结构，但是串行队列只能往一个队列中添加任务，一定会按照放入队列的顺序进行顺序执行；

并发队列可以往多个队列中添加任务，等待线程执行队列中的任务，线程的调度队列的情况和任务的复杂度决定了任务的执行顺序。

以上就是iOS开发探索多线程GCD队列示例详解的详细内容，更多关于iOS开发多线程GCD队列的资料请关注我们其它相关文章！