广告
返回顶部
首页 > 资讯 > 移动开发 >iOS开发探索多线程GCD队列示例详解
  • 354
分享到

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

2024-04-02 19:04:59 354人浏览 独家记忆
摘要

目录引言进程与线程1.进程的定义2.线程的定义3、 进程和线程的关系4、 多线程5、 时间片6、 线程池GCD1、任务2、队列3、死锁总结引言 在iOS开发过程中,绕不开网络请求、下

引言

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队列的资料请关注编程网其它相关文章!

--结束END--

本文标题: iOS开发探索多线程GCD队列示例详解

本文链接: https://www.lsjlt.com/news/165230.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑,方便收藏和打印~

下载Word文档
猜你喜欢
  • iOS开发探索多线程GCD队列示例详解
    目录引言进程与线程1.进程的定义2.线程的定义3、 进程和线程的关系4、 多线程5、 时间片6、 线程池GCD1、任务2、队列3、死锁总结引言 在iOS开发过程中,绕不开网络请求、下...
    99+
    2022-11-13
  • iOS开发探索多线程GCD任务示例详解
    目录引言同步任务死锁异步任务总结引言 在上一篇文章中,我们探寻了队列是怎么创建的,串行队列和并发队列之间的区别,接下来我们在探寻一下GCD的另一个核心 - 任务 同步任务 void ...
    99+
    2022-11-13
  • iOS开发探索多线程GCD常用函数
    目录正文单例栅栏函数调度组 dispatch_group_t信号量 dispatch_semaphore_tdispatch_source总结正文 前篇文章我们了解了GCD的任务的原...
    99+
    2022-11-13
  • iOS开发底层探索界面优化示例详解
    目录1、卡顿原理1.1、界面显示原理1.2、界面撕裂1.3、界面卡顿小结2、卡顿检测2.1、CADisplayLink2.2、RunLoop检测2.3、微信matrix2.4、滴滴D...
    99+
    2022-11-13
软考高级职称资格查询
编程网,编程工程师的家园,是目前国内优秀的开源技术社区之一,形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容,为IT开发者提供了一个发现、使用、并交流开源技术的平台。
  • 官方手机版

  • 微信公众号

  • 商务合作