iOS——【GCD】

糸师凛

已于 2024-05-28 20:31:47 修改

阅读量965

点赞数 26

文章标签： ios

于 2024-03-26 18:43:22 首次发布

本文链接：https://blog.csdn.net/m0_73348697/article/details/137054310

版权

GCD

什么是GCD

GCD指的是Grand Central Dispatch，它是苹果公司开发的一套多线程编程技术。GCD提供了一种简单而有效的方式来管理应用程序中的并发任务。它通过将任务提交到适当的队列（串行队列或并发队列）来管理并发执行的任务，从而帮助开发者更轻松地实现并发编程，提高应用程序的性能和响应速度。
使用GCD的好处：

GCD可用于多核的并行运算
GCD会自动利用更多的CPU内核（双核、四核）
GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码

GCD源代码的例子：


dispatch_async(queue, ^{
/* 长时间处理
例如AR用画像识别、数据库访问*/

/* 长时间处理结束，主线程使用该处理结果。 */
  dispatch_async(dispatch_get_main_queue(), ^{ 
  /* 只在主线程可以执行的处理
     例如UI界面更新 */
  });
});

上面的就是在后合线程中执行长时间处理，处理结束时，主线程使用该处理结果的源代码。

这样，dispatch_async (queue, ^{ 这仅有一行的代码表示让处理在后台线程中执行。
dispatch_async(dispatch_get_main_queue (), ^{ 仅此一行代码就能够让处理在主线程中执行。

在导入GCD之前还有performSelector系列方法来实现多线程编程，但是在蓝书的学习中我们说过要多用GCD少用performSelector系列方法。详见：

多线程编程

首先认识几个基本概念：

进程：

进程是一个具有一定独立功能的程序关于某次数据集合的一次运行活动，每个进程都有自己独立的一块内存空间，进程是操作系统分配资源的基本单元.
进程是指在系统中正在运行的一个应用程序，就是一段程序的执行过程,我们可以理解为手机上的一个 app
每个进程之间是独立的，每个进程均运行在其专用且受保护的内存空间内，拥有独立运行所需的全部资源。

线程

线程是进程中执行运算的最小单位，是进程中的一个实体。
线程是系统独立调度和分派的基本单位，线程自己不拥有系统资源，只拥有一点在运行中必不可少的资源。
一个进程至少有一个线程，应用程序启动的时候，系统会默认开启一条线程，也就是主线程。一个进程可以运行多个线程，多个线程可共享进程所拥有的全部资源。同一进程中的多个线程之间可以并发执行。

线程与进程的关系

线程是进程的执行单元，进程的所有任务都在线程中执行
线程作为调度和分配的基本单位，进程作为拥有资源的基本单位
一个程序可以对应多个进程(多进程)，一个进程中可有多个线程，但至少要有一条线程
同一个进程内的线程共享进程资源

源代码实际上在Mac 或iPhone 上是如何执行的呢？
源代码通过编译器转换为CPU命令列(二进制代码 ) 。
汇集CPU命令列和数据，将其作为一个应用程序安装到Mac或iPhone 上。启动该应用程序后，首先便将CPU命令列配置到内存中。CPU从应用程序指定的地址开始，一个一个地执行CPU 命令列。就这样不断循环下去。
执行命令列的地址会远离当前的位置(位置迁移)。但是，由于一个CPU一次只能执行一个命令，不能执行某处分开的并列的两个命令，因此通过CPU执行的CPU命令列就好比一条无分叉的大道，其执行不会出现分歧。
“一条无分叉的大道〞即为“线程”。这种无分叉路径不只1条，存在有多条时即为“ 至线程”。

1个CPU核一次能够执行的CPU 命令始终为1。那么怎样才能在多条路径中执行CPU 命令列呢？

在具有多个CPU 核的情况下，提供了多个CPU校并行执行多个线程的技术。这种利用多线程编程的技术就被称为“ 多线程编程”。
但是，多线程编程实际上是一种易发生各种问题的编程技术。比如多个线程更新相同的资源会导致数据的不一致(数据竞争)、停止等待事件的线程会导致主个线程相互持续等待(死锁)、使用太多线程会消耗大量内存等。

应用程序在启动时，通过最先执行的线程，即“ 主线程” 来描绘用户界面、处理触摸屏幕的事件等。如果在该主线程中进行长时间的处理，如AR 用画像的识别或数据库访问，就会妨碍主线程的执行(阻塞)。在oS ×和i0s 的应用程序中，会妨碍主线程中被称为RunLoop 的主循环的执行，从而导致不能更新用户界面、应用程序的画面长时间停滞等问题。这就是长时间的处理不在主线程中执行而在其他线程中执行的原因。

使用多线程编程，在执行长时间的处理时仍可保证用户界面的响应性能。

GCD的API

Dispatch Queue

首先回顾一下苹果官方对GCD 的说明。

开发者要做的只是定义想执行的任务井追加到适当的Dispatch Queue 中。
这句话用源代码表示如下:

dispatchasync (queue, ^{
/* 想执行的任务*/
});

该源代码使用Block 语法“定义想执行的任务”，通过dispatch_async函数“追加” 赋值在变量 queue的 “Dispatch Queue中 ” 。仅这样就可使指定的Block在另一线程中执行。
“Dispatch Queue ” 是执行处理的等待队列。应用程序编程人员通过dispatch_async 函数等API，在Block 语法中记述想执行的处理并将其追加到Dispatch Queue 中。Dispatch Queue 按照追加的顺序 (先进先出)执行处理。
在执行处理时存在两种Dispatch Queue，一种是等待现在执行中处理的Serial Dispatch Queue，另一种是不等待现在执行中处理的Concurrent Dispatch Queue。

当变量queue 为Concur rent Dispatch Queue 时，不用等待处理结束，可以并行执行多个处理，但并行执行的处理数量取决于当前系统的状态。即基于 Dispatch Queue中的处理数、CPU核数以及CPU负荷等当前系统的状态来快定Concurrent Dispatch Queue 中并行执行的处理数。

在Concurrent DispatchQueue中执行处理时，执行顺序会根据处理内容和系统状态发生改变。它不同于执行顺序固定的Serial Dispatch Queue。在不能改变执行的处理顺序或不想并行执行多个处理时使用Serial DispatchQueue。

dispatch_queue_create

如何才能得到Dispatch Queue呢？第一种方法是通过GCD的API 生成Dispatch Queue，即dispatch_queue_create；

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

参数1：指定生成返回的Dispatch Queue的名称
该名称在Xcode和Instruments的调试器中作为Dispatch Queue的名称表示，该名称也会出现在程序崩溃时所生成的CrashLog中；队列的名称推荐使用应用程序 ID 这种逆序全程域名。
参数2:指定为NULL或DISPATCH_QUEUE_SERIAL，生成Serial Dispatch Queue

指定为DISPATCH_QUEUE_CONCURRENT，生成Concurrent Dispatch Queue
虽然Serial Dispatch Queue 和Concurrent Dispatch Queue受到系统资源的限制，但用dispatch_queue_create 函数可生成任意多个Dispatch Queue。
当生成多个Serial Dispatch Queue时，各个Serial Dispatch Queue 将并行执行。
一旦生成Serial DispatchQueue 并追加处理，系统对于一个Serial DispatchQueue 就只生成并使用一个线程。
因此只在为了避免多线程编程问题之一一一多个线程更新相同资源导致数据竞争时使用 Serial DispatchQueue。
当想并发执行不发生数据竞争等问题的处理时，使用 Concurrent Dispatch Queue
iOS6之前，Dispatch Queue 需要进行手动管理释放，现已纳入ARC管理范围。

生成Serial Dispatch Queue 时，像该源代码这样，将第二个参数指定为NULL。生成 Concurrent Dispatch Queue时，像下面源代码一样，指定为 DISPATCH_QUEUECONCURRENT。

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

dispatch_queuecreate 西数的返回值为表示Dispatch Queue 的 “dispatch queue t 类型”。在之前源代码中所出现的变量queue 均为dispatch_queue_t 类型变量.

Main Dispatch Queue/Global Dispatch Queue

第二种方法是获取系统标准提供的Dispatch Queue。
Main DispatchQueve是在主线程中执行的Dispatch Queue。因为主线程只有1个，所以Main DispatchQueue 自然就是SerialDispatchQueue。
Global Dispatch Queue 有4个执行优先级，分别是高优先级、默认优先级、低优先级、后台优先级。

各种Dispatch Queue 的获取方法如下：

// Main Dispatch Queve的获取方法
dispatch_queue_t mainDispatchQueue = dispatch_get_main_queue ( ) 

//Global DispatchQueue(高优先级〕的获取方法
dispatch_queue_t globalDispatchQueueHigh =
dispatch_get_global_queue(DISPATCHQUEUEPRIORITY_HIGH, 0);

//Global DispatchQueue(默认优先级)的获取方法 
dispatch_queue_t globalDispatchQueueDefault =
dispatch_get_global_queue(DISPAICH_QUEUE_PRIORITY_DEFAULT,0);

//Global Dispatch Queue (低优先级)的获取方法 
dispatch_queue_t globalDispatchQueueLow = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);

//Global Dispatch Queue(后台优先级)的获取方法
dispatch_queue_t globalDispatchQueueBackground =
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND,
0) :

dispatch_set_target_queue

dispatch_queue_create 两数生成的Dispatch Queue 不管是Serial Dispatch Queue 还是Concurrent Dispatch Queue，都使用与默认优先级Global Dispat ch Queue 相同执行优先级的线程。

SerialDispatchQueue 的生成方法如下:

dispatch_queue_t mySerialDispatchQueue =
dispatch_queue_create("com.example.gcd.MySerialDispatchQueue", NULL);
dispatch_queue_t globalDispatchQueueBackground =
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND,0); 
dispatch_set_target_queue(mySerialDispatchQueue, globalDispatchQueueBackground);

将Dispatch Queue 指定为dispatch_settargetqueue 函数的参数，不仅可以变更Dispatch Queue 的执行优先级，还可以作成DispatchQueue 的执行阶层。如果在多个Serial DispatchQueue 中用 dispatch_set_target_queue两数指定目标为某一个SerialDispatchQueue，那么原先本应并行执行的多个Serial Dispatch Queue，在目标Serial Dispatch Queue 上只能同时执行一个处理。

dispatch_after

这种想在指定时间后执行处理的情况，可使用dispatch_after 两数来实现。
在 3 秒后将指定的 B l o c k 追加到 M a i n D i s p a t c h Q u e u e 中的源代码如下:

dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3ull * NSEC_PER_SEC); 
dispatch_after(time, dispatch_getmain_queue(), ^{
  NSLog (@"waited at least three seconds."); 
});

dispatch_time 函数能够获取从第一个参数dispatch_time_t 类型值中指定的时间开始，到第二个参数指定的毫微秒单位时间后的时间。第一个参数经常使用的值是之前源代码中出现的 DISPATCH_TIME_NOW。这表示现在的时间。即以下源代码可得到表示从现在开始 1 秒后的 dispatch time t 类型的值。

dispatch_time_t time =dispatch_time(DISPATCHL_TIME_NOW, 1u11*NSEC_PER_SEC);

数值和NSEC_PERSEC的乘积得到单位为毫微秒的数值。“ull” 是C语言的数值字面量，是显式表明类型时使用的字符串 (表示 “ unsigned long long ” ) 。

Dispatch Group

在追加到Dispatch Queue 中的多个处理全部结束后想执行结束处理，这种情况会经常出现。只使用一个Serial Dispatch Queue时，只要将想执行的处理全部追加到该Serial Dispatch Queue 中并在最后追加结束处理，即可实现。但是在使用Concurrent Dispatch Queue 时或同时使用多个 Dispatch Queue 时，源代码就会变得颇为复杂。
在此种情况下使用Dispatch Group。
例：追加了个Block到Global Dispatch Queue，这些Block 如果全部执行完牛，就会执行Main Dispatch Queue中结束处理用的Block。

dispatch_queue_t queue =
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue,^{
  NSLog(@"b1k0”);});  
dispatch_group_async(group, queue, ^{
  NSLog (@"blk1”);});
dispatch_group_async(group, queue, ^{
  NSLog (@"b1k2”);});
dispatch_group_notify (group,dispatch_get_main_queue (), ^{NSLog (@"done”);});
dispatch_release(group);

因为向Global DispatchQueue 即Concurrent DispatchQueue 追加处理，多个线程并行执行，所以追加处理的执行顺序不定。执行时会发生变化，但是此执行结果的done 一定是最后输出的。
无论向什么样的Dispatch Queue 中追加处理，使用Dispatch Group 都可监视这些处理执行的结束。一旦检测到所有处理执行结束，就可将结束的处理追加到Dispatch Queue 中。这就是使用 Dispatch Group 的原因。

在DispatchGroup 中也可以使用dispatch_group_wait 两数仅等待全部处理执行结束:

dispatch_group_wait(group, DISPATCH_TIME_FOREVER); dispatch_release(group);

指定DISPATCH_TIME NOW，则不用任何等待即可判定属于Dispatch Group 的处理是否执行结束。

long result = dispatch_group_wait(group,DISPATCH_TIME_NOW);

dispatch_barrier_async

在访问数据库或文件时，如前所述，使用Serial Dispatch Queue 可避免数据亮争的问题。
写入处理确实不可与其他的写入处理以及包含读取处理的其他某些处理并行执行。但是如果读取处理只是与读取处理并行执行，那么多个并行执行就不会发生问题。

虽然利用DispatchGroup和dispatchsettarget queue两数也可实现，但是源代码会很复杂。 GCD 为我们提供了更为聪明的解决方法——- dispatch barrier_async 两数。该函数同dispatch queue_create函数生成的Concurrent DispatchQueue一起使用。
首先dispatch queue create 函数生成Concurrent Dispatch Queue，在dispatch_async 中追加读取处理。

dispatch_queue_t queue = dispatch_queue_create (
"com. example.god. ForBarrier", DISPATCH_QUEUE_CONCURRENT) :
dispatch_async (queue, blk0_for_reading); dispatch_async(queue, blklf o rreading);
dispatch_async (queue, b1k2_for_reading) ; dispatch_async (queue, b1k3_for_ reading);
dispatch_async (queue, bik4_for_reading) ; 
dispatch_async(queue, bik5f o rreading);
dispatch_async (queue, blk6_for_reading) ; dispatch_async (queue, blk7_for_reading);
dispatch_release (queue);

在blk3_for_reading 处理和blk4_for_reading 处理之间执行写入处理，并将写入的内容读取 blk4_for_reading 处理以及之后的处理中。

dispatch_async ( queue, b1k0_for_reading) ;
dispatch async (queue, blk1 f o rreading) ;
dispatch_async (queue, b1k2_for_reading) ; dispatchasync (queue, bik3f o rreading)
/*
* 写入处理
* 将写入的内容读取之后的处理中 */
dispatch_async ( queue, b1k4_for_reading) ;
dispatch_async ( queue, b1k5_for_reading);
dispatch_async (queue, b1k6_for_reading); dispatch_async (queue, b1k7_for_ reading);

这时我们要使用dispatch_barrier_async 函数。dispatch barrier_async 函数会等待追加到 Concurent Dispatch Queue 上的并行执行的处理全部结束之后，再将指定的处理追加到该 Concurrent DispatchQueue 中。然后在由dispatch_barrier_async 函数追加的处理执行完牛后， Concurrent Dispatch Queue 才恢复为一般的动作，追加到该Concurrent DispatchQueue 的处理又开始并行执行。

dispatch_async(queue, bik0_for_reading): 
dispatch_async (queue, blk1_for_reading) ;
dispatch_async (queue, b1k2_for_reading);
dispatch_async (queue, b1k3_for_reading); dispatch_barrier_async(queue, blk_for_writing);
dispatch_async (queue, bik4_for_reading); 
dispatch_async (queue, blk5_for_reading) ;
dispatch_async (queue, blk6_for_reading); dispatch_async (queue, b1k7_for_reading);

使用Concurrent Dispatch Queue 和dispatch barrier_async 函数可实现高效率的数据库访问和文件访问。

dispatch_sync

dispatch async函数的“async” 意味着“非同步”(asynchronous)，就是将指定的Block“非同步” 地追加到指定的Dispatch Queue中。dispatch_async 函数不做任何等待。
既然有“async”，当然也就有“sync”，即dispatch_sync 函数。它意味着“ 同步”，也就是将指定的 B l o c k “ 同步 ” 追加到指定的 D i s p a t c h Q u e u e 中。在追加 B l o c k 结束之前，dispatch_sync 两数会一直等待。
“ 等待〞意味着当前线程停止。
假设执行Main Dispatch Queue 时，使用另外的线程Global Dispatch 进行处理，处理结束后立即使用所得到的结果。在这种情况下就要使用dispatch sync函数。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_sync(queue, ^{
  // 处理
};

一旦调用dispatch_sync 两数，那么在指定的处理执行结束之前，该函数不会返回。dispatch sync两数可简化源代码，也可说是简易版的dispatch _group_wait 函数。
正因为dispatch sync 两数使用简单，所以也容易引起问题，即死锁。
例如如果在主线程中执行以下源代码就会死锁。

dispatch_queue_t queue = dispatch_get_main_queue(); dispatch_sync(queue, ^{NSLog (@"Hello?”);});

该源代码在Main Dispatch Queue 即主线程中执行指定的Block，并等待其执行结束。而其实在主线程中正在执行这些源代码，所以无法执行追加到Main DispatchQueue的Block。下面例子也一样。

dispatch_queue_t queue = dispatch_get_main_queue () ; dispatch_async (queue, ^{
dispatchsync (queue, ^{NSLog (@"Hello?");});
});

MainDispatchQueue中执行的Block 等待MainDispatch Queue 中要执行的Block 执行结束。

Serial Dispatch Queue 也会引起相同的问题。

dispatch_queue_t queue = dispatch_queue_create("com.example.gcd.MySerialDispatchQueue”,NULL);
dispatch_async(queue, ^{
  dispatch_sync (queue, ^ (NSLog (@"Hello?"); }); 
}):

相应的也有dispatch_barrier_ sync 函数，它会等待追加处理的执行结束。

dispatch_apply

dispatch_apply 函数是dispatch_sync 函数和Dispatch Group 的关联API 。该函数按指定的次数将指定的Block追加到指定的Dispatch Queue 中，并等待全部处理执行结束。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(10, queue, ^(size_t index){
  NSLog (@"&zu", index);
});
NSLog(@“done”);

该代码的执行结果是：4 1 0 3 5 2 6 8 9 7 done
因为在Global Dispatch Queue 中执行处理，所以各个处理的执行时间不定。但是输出结果中最后的 d o n e 必定在最后的位置上。这是因为dispatch_apply函数会等待全部处理执行结束。

由于dispatch_apply 函数也与dispatch_sync 函数相同，会等待处理执行结束，因此推荐在dispatch_async 函数中非同步地执行dispatch_apply 函数。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_ DEFAULT, 0);
//在Global DispatchQueve中非同步执行
dispatch_async(queue, ^{
  //Global Dispatch Oueue
  //等待dispatch_apply函数中全部处理执行结束
  dispatch_apply ([array count], queue, ^(size_t index){
    //并列处理包含在NSAr r a y 对象的全部对象
    NSLog(@"&zu: %@", index, [array objectAtIndex:index]);
  });
// dispatch apply西数中的处理全部执行结束
//在Main Dispatch Queue中非同步执行
  dispatch_async(dispatch_get_main_queue(), ^{
//在 Ma i n D i s p a t c h Q u e u e 中 执 行 处 理,用户界面更新等
  NSLog ( @"done" ) ;
  });
});

dispatch_suspend / dispatch_resume

dispatch_suspend函数用于挂起不希望执行的Dispatch Queue：

dispatch_suspend(queue);

dispatch_resume函数用于恢复被挂起的Dispatch Queue：

dispatch_resume(queue);

这些函数对己经执行的处理没有影响。挂起后，追加到Dispatch Queue 中但尚末执行的处理在此之后停止执行。而恢复则使得这些处理能够继续执行。

Dispatch Semaphore

Dispatch Semaphore是持有计数的信号，该计数是多线程编程中的计数类型信号。计数为0时等待，计数为1或者大于1时，计数减一而不等待。
使用方法：
使用dispatch_semaphore_create函数生成dispatch_semaphore_t类型的Dispatch Semaphore。

dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);

参数表示的是计数的初始值。
该函数课通过dispatch_retain持有，通过dispatch_release释放。

dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

dispatch_semaphore_wait函数等待Dispatch Semaphore的计数值达到1或者等于1。当计数值大于等于1，或者在待机中计数值大于等于1时，对该计数进行减法并从dispatch_semaphore_wait函数返回。可通过函数返回值进行达到一些希望的目的和操作。

dispatch_time_t time =dispatch_time( DISPATCH_TIME_NOW, 1U11 * NSEC_PER_SEC); 
long result = dispatch_semaphore_wait(semaphore, time);
if(result ==0){
/*
由于Dispatch Semaphore的计数值达到大于等于1或者在待机中的指定时间内
* Dispatch Semaphore的计数值达到大于等于1
*所以Dispatch Semaphore的计数值减去1。
*可执行需要进行排他控制的处理*/
} else {
/*
*由于Dispatch Semaphore的计数值为0*因此在达到指定时间为止待机
*/
}

dispatch_semaphore_wait函数返回0时，可安全地执行需要进行排他控制的处理。该处理结束时通过dispatch_semaphore_signal函数将Dispatch Semaphore的计数值加1。

dispatch_once

dispatch_once 函数是保证在应用程序执行中只执行一次指定处理的API。
使用dispatch once 函数，源代码写为:

static dispatch_once_t pred;
dispatch_once(&pred, ^{
  // 初始化
});

通过dispatch_once 函数，该源代码即使在多线程环境下执行，也可保证百分之百安全。

Dispatch I/O

现今的输入/输出硬件己经可以做到一次使用多个线程更快地并列读取了。能实现这一功能的就是Dispatch I/O 和Dispatch Data。如果想提高文件读取速度，可以尝试使用Di spatch I/O。

GCD 实现

Dispatch Queue

DispatchQueue究竟是如何实现的呢?

用于管理追加的 B l o c k 的 C 语言层实现的 F I F O 队列
Atomic 两数中实现的用于排他控制的轻量级信号
用于管理线程的 C 语言层实现的一些容器

通常，应用程序中编写的线程管理用的代码要在系統级实现。

使用 G C D 要比使用一般的多线程编程 A P I 更好。并且，如果使用GCD 就不必编写为操作线程反复出现的类似的源代码 (这被称为固定源代码片断)，而可以在线程中集中实现处理内容，真的是好处多多。我们尽量多使用GCD 或者使用了Cocoa 框架GCD 的NSOperationQueue 类等API.

Global DispatchQueue 有如下8种。
• Global Dispatch Queue (High Priority)
• Global Dispatch Queue (Default Priority) • Global Dispatch Queue (Low Priority)
• Global Dispatch Queue (Background Priority)
• Global Dispatch Queue (High Overcommit Priority)
• Global Dispatch Queue (Default Overcommit Priority) • Global Dispatch Queue (Low Overcommit Priority )
• Global Dispatch Queue (Background Overcommit Priority)
优先级中附有Overcommit 的Global Dispatch Queue 使用在Serial Dispatch Queue 中。如 Overcommit 这个名称所示，不管系统状态如何，都会强制生成线程的DispatchQueuc。这8种Gilobal DispatchQueue各使用1个ptbread_workqueue。GCD初始化时，使用pthread_workqueue _create _np 两数生成 pthread_workqueue。
pthread_workqueue 包含在Libe提供的pthreads API 中。其使用bsdthreadr egister 和worka open 系统调用，在初始化 XNU 内核的workqueue 之后获取workqueue 信息。

XNU 内核持有4 种workqueue 。
• WORKQUEUE HIGHPRIOQUEUE
• WORKQUEUE DEFAULTPRIOQUEUE
• WORKQUEUE_ LOW PRIOQUEUE • WORKQUEUE_BG_PRIOQUEUE
以上为4 种执行优先级的workqueue。该执行优先级与Global Dispatch Queue 的4 种执行优先级相同。

Dispatch Source

Dispatch Source是BSD系内核惯有功能kqueue的包装。kqueue是在XNU内核中发生各种事件时，在应用程序编程方执行处理的技术。其CPU符合非常小，尽量不占用资源。
Dispatch Source可处理以下事件：

在这里插入图片描述

Dispatch Source与Dispatch Queue的不同是，后者可以将追加的执行处理取消，而前者则不能。

实际上Dispatch Queue没有“取消” 这一概念。一旦将处理追加到DispatchQueue 中，就没有方法可将该处理去除，也没有方法可在执行中取消该处理。编程人员要么在处理中导入取消这一概念，要么放弃取消，或者使用NSOperationQueue 等其他方法。

糸师凛

关注

26
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
iOS——【GCD】

GCD指的是Grand Central Dispatch，它是苹果公司开发的一套多线程编程技术。GCD提供了一种简单而有效的方式来管理应用程序中的并发任务。它通过将任务提交到适当的队列（串行队列或并发队列）来管理并发执行的任务，从而帮助开发者更轻松地实现并发编程，提高应用程序的性能和响应速度。上面的就是在后合线程中执行长时间处理，处理结束时，主线程使用该处理结果的源代码。这样，dispatch_async (queue, ^{ 这仅有一行的代码表示让处理在后台线程中执行。
复制链接

扫一扫