iOS开发多线程GCD队列
懒的问苍天 人气:0引言
在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的数据结构,但是串行队列只能往一个队列中添加任务,一定会按照放入队列的顺序进行顺序执行;
并发队列可以往多个队列中添加任务,等待线程执行队列中的任务,线程的调度队列的情况和任务的复杂度决定了任务的执行顺序。
加载全部内容