iOS - 多线程（三）：GCD

最新推荐文章于 2024-07-17 20:45:30 发布

师大小海腾

最新推荐文章于 2024-07-17 20:45:30 发布

阅读量358

点赞数

本文链接：https://blog.csdn.net/weixin_42350379/article/details/104566826

版权

iOS - 多线程系列文章

iOS - 多线程（一）：初识
 iOS - 多线程（二）：pthread、NSThread
iOS - 多线程（三）：GCD
iOS - 多线程（四）：NSOperation
iOS - 多线程（五）：线程同步方案

网络配图.jpg

1. GCD 初识

1.1 GCD 介绍

全称是 Grand Central Dispatch，也简称 Dispatch；
纯 C 语言，提供了非常多强大的函数；
GCD 是苹果公司为多核的并行运算提出的解决方案；
GCD 会自动充分利用设备的多核（比如双核、四核）；
GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）；
开发者只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码。

1.2 GCD 的使用步骤

GCD 的两个核心

任务：执行什么操作
队列：用来存放任务

GCD 的任务

GCD 中的任务有两种封装：dispatch_block_t 和 dispatch_function_t。

$\color{red}{●}$ dispatch_block_t（常用）

提交给指定队列的 block，无参无返回值。

typedef void (^dispatch_block_t)(void);

$\color{red}{●}$ dispatch_function_t

提交给指定队列的 function，void(*)()类型的函数指针。

typedef void (*dispatch_function_t)(void *);

GCD 的使用步骤

创建/获取队列：创建/获取一个并发/串行队列；
创建任务：确定要做的事；
将任务添加进队列中（同时指定任务的执行方式）：

GCD 会自动将队列中的任务取出，放到对应的线程中执行；
任务的取出遵循队列的 FIFO 原则：先进先出，后进后出；
GCD 中，要执行队列中的任务时，会自动开启一个线程，当任务执行完，线程不会立刻销毁，而是放到了线程池中。如果接下来还要执行任务的话就从线程池中取出线程，这样节省了创建线程所需要的时间。但如果一段时间内没有执行任务的话，该线程就会被销毁，再执行任务就会创建新的线程。

队列 FIFO 原则

    // 1.创建一个队列
    dispatch_queue_t queue = dispatch_queue_create("myqueue", DISPATCH_QUEUE_SERIAL);
    // 2.创建一个任务
    dispatch_block_t block = ^{
   
        NSLog(@"%@",[NSThread currentThread]);
    };
    // 3.将任务添加进队列中（同时指定任务的执行方式）  
    dispatch_async(queue, block);

1.3 GCD 执行任务的方式

1.3.1 同步

$\color{red}{●}$ dispatch_sync

提交一个 block 对象到指定队列以同步执行，并在该 block 完成执行后返回（阻塞）。
（因为这个特性，使用该函数要注意死锁的问题，后面会讲到）

/*!
 * @param queue
 * 提交block的队列，这个队列会被系统retain直到block运行完成；
 * 此参数不能为空（NULL）
 *
 * @param block
 * 要执行的block，block会被自动copy与release；
 * 该block没有返回值，也没有参数；
 * 此参数不能为空（NULL）
 */
void dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

- (void)test
{
   
    dispatch_queue_t queue = dispatch_queue_create("com.junteng.queue", DISPATCH_QUEUE_SERIAL);
    NSLog(@"0");
    dispatch_sync(queue, ^{
   
        NSLog(@"1");
    });
    dispatch_sync(queue, ^{
   
        NSLog(@"2");
    });
    NSLog(@"3");
}
/*
2020-01-31 20:35:48.958272+0800 多线程[4653:706706] 0
2020-01-31 20:35:48.958533+0800 多线程[4653:706706] 1
2020-01-31 20:35:48.958696+0800 多线程[4653:706706] 2
2020-01-31 20:35:48.958810+0800 多线程[4653:706706] 3
 */

$\color{red}{●}$ dispatch_sync_f

提交一个 function 到指定队列以同步执行，并在该 function 完成执行后返回（阻塞）。

/*!
 * @param queue
 * 提交函数的队列，这个队列会被系统retain直到block运行完成；
 * 此参数不能为空（NULL）
 *
 * @param context
 * 传递给函数的参数，即work的参数
 * 
 * @param work
 * 要执行的函数；
 * 此参数不能为空（NULL）
 */
void dispatch_sync_f(dispatch_queue_t queue, void *context, dispatch_function_t work);

- (void)test
{
   
    dispatch_queue_t queue = dispatch_queue_create("com.junteng.queue", DISPATCH_QUEUE_SERIAL);
    NSLog(@"0");
    dispatch_sync_f(queue, NULL, testFunc);
    NSLog(@"2");
}

void testFunc() {
   
    NSLog(@"1");
}
/*
2020-01-31 21:05:35.017838+0800 多线程[4757:726399] 0
2020-01-31 21:05:35.017959+0800 多线程[4757:726399] 1
2020-01-31 21:05:35.018047+0800 多线程[4757:726399] 2
 */

1.3.2 异步

$\color{red}{●}$ dispatch_async

提交一个 block 对象到指定队列以异步执行，并直接返回（不会阻塞）。

void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

- (void)test
{
   
    dispatch_queue_t queue = dispatch_queue_create("com.junteng.queue", DISPATCH_QUEUE_SERIAL);
    NSLog(@"0");
    dispatch_async(queue, ^{
   
        NSLog(@"1");
    });
    dispatch_async(queue, ^{
   
        NSLog(@"2");
    });
    NSLog(@"3");
}
/*
2020-01-31 21:09:43.675233+0800 多线程[4801:730375] 0
2020-01-31 21:09:43.675389+0800 多线程[4801:730375] 3
2020-01-31 21:09:43.675458+0800 多线程[4801:730469] 1
2020-01-31 21:09:43.675550+0800 多线程[4801:730469] 2
 */

$\color{red}{●}$ dispatch_async_f

道理同 dispatch_sync_f，不再赘述。

1.3.3 同步和异步的区别

同步：必须等待当前语句执行完毕，才会执行下一条语句（阻塞）；
在当前线程中执行任务，不具备开启新线程的能力。
异步：不用等待当前语句执行完毕，就可以执行下一条语句（不会阻塞）；
在新的线程中执行任务，具备开启新线程的能力。
（具备开启新线程的能力，不代表一定能开启新线程。如在主队列异步执行，不会开启新线程，因为主队列的任务在主线程上执行）

1.4 GCD 的队列

1.4.1 GCD 队列介绍

Dispatch Queue： 一个用于管理主线程或子线程上串行或并发执行的任务的对象。
调度队列是 FIFO 队列，您可以以 block 对象的形式向其提交任务。调度队列可以串行或并发执行任务。提交给调度队列的任务在系统管理的线程池上执行。除了主队列在主线程上执行以外，系统无法保证它使用哪个线程来执行任务。

1.4.2 GCD 队列类型

串行队列（DISPATCH _QUEUE _SERIAL）
以 FIFO 顺序处理传入的任务，即让任务一个接着一个执行。
并发队列（DISPATCH _QUEUE _CONCURRENT）
可以让多个任务并发（同时）执行（自动开启多个线程执行任务）；
并发功能只有在异步函数dispatch_async下才有效；
尽管任务同时执行，但是您可以使用 barrier 栅栏函数在队列中创建同步点（关于栅栏函数后面会讲到）。
主队列（dispatch_queue_main_t）
主队列是一种特殊的串行队列，它特殊在与主线程关联，主队列的任务都在主线程上执行，主队列在程序一开始就被系统创建并与主线程关联。

$\color{red}{●}$ dispatch_get_main_queue

// @return 主队列
dispatch_queue_main_t dispatch_get_main_queue(void);

系统创建主队列并与主线程进行关联的时机：
① 调用 dispatch_main()；
② 调用 UIApplicationMain（iOS）或者 NSApplicationMain（macOS）；
③ 在主线程使用 CFRunLoopRef。
大多数情况下我们的应用程序会在 main() 函数里使用第 2 种方式。

全局并发队列（dispatch_queue_global_t）
一种特殊的并发队列，可以指定服务质量（服务质量有助于确定队列执行的任务的优先级）。

$\color{red}{●}$ dispatch_get_global_queue

/*!
 * @param identifier
 * 队列的服务质量，传0就是默认
 *
 * @param flags
 * 苹果留着以后用的，传0就行
 * 
 * @return dispatch_queue_global_t
 * 可以指定服务质量的系统定义的全局并发队列
 */
dispatch_queue_global_t dispatch_get_global_queue(long identifier, unsigned long flags);

注意： 对主队列和全局并发队列使用dispatch_suspend、dispatch_resume、dispatch_set_context是无效的。

全局并发队列与手动创建的并发队列的区别：

手动创建的并发队列可以设置唯一标识，可以跟踪错误，而全局并发队列没有；
在 ARC 中不需要考虑释放内存，dispatch_release(q);不需要也不允许调用。而在 MRC 中由于手动创建的并发队列是 create 出来的，所以需要调用dispatch_release(q);来释放内存，而全局并发队列不需要;
全局并发队列可以指定服务质量（服务质量有助于确定队列执行的任务的优先级）;
一般我们使用全局并发队列。

$\color{red}{●}$ dispatch_queue_t（队列）

应用程序向其提交块（任务）以进行后续执行的轻量级对象，它是一个对象，这也很好的解释了在 MRC 下为何要手动管理dispatch_queue_t的内存。
队列遵循 FIFO 原则。串行队列一次只能调用一个块，但是不同队列可以各自相对于彼此同时调用它们的块。并发队列也是按 FIFO 顺序调用块，但不等待它们完成，从而允许并发调用多个块。
系统管理一个线程池，该线程池处理队列并调用提交给它们的块。
队列是通过调用dispatch_retain和dispatch_release来进行引用计数的。提交到队列的待处理块也保留对该队列的引用，直到它们完成为止。一旦释放了对队列的所有引用，系统将重新分配该队列。

typedef NSObject<OS_dispatch_queue> *dispatch_queue_t;

$\color{red}{●}$ dispatch_queue_create

创建队列。

/*!
 * @param label
 * 给队列一个字符串标签进行唯一标识，以便在调试时区分队列
 * 建议使用反向DNS命名方式（com.example.myqueue）
 * 该参数可以为空（NULL）
 *
 * @param attr
 * 指定队列类型
 * DISPATCH_QUEUE_SERIAL     为串行队列
 * DISPATCH_QUEUE_CONCURRENT 为并发队列
 * 该参数可以为空（NULL），传空时默认为串行队列（在iOS4.3版本之前该参数只能传空）
 * 
 * @return dispatch_queue_t
 * 新创建的队列
 */
dispatch_queue_t dispatch_queue_create(const char *label, dispatch_queue_attr_t attr);

创建/获取一个队列：

// 创建一个串行队列 
dispatch_queue_t queue = dispatch_queue_create("com.junteng.myqueue", DISPATCH_QUEUE_SERIAL);
// 创建一个并发队列
dispatch_queue_t queue = dispatch_queue_create("com.junteng.myqueue", DISPATCH_QUEUE_CONCURRENT);
// 获取主队列
dispatch_queue_t queue = dispatch_get_main_queue();
// 获取全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

$\color{red}{●}$ dispatch_queue_get_label

获取队列的唯一标识 label。

/*!
 * @param queue
 * 需要获取label的队列;
 * 如果需要获取当前队列的label则使用 DISPATCH_CURRENT_QUEUE_LABEL
 * 
 * @return 
 * 创建队列时给队列设置的标签
 */
const char * dispatch_queue_get_label(dispatch_queue_t queue);

    dispatch_queue_t queue = dispatch_queue_create("com.junteng.myqueue", NULL);
    dispatch_sync(queue, ^{
   
        NSLog(@"%s", dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL));
    });
    NSLog(@"%s", dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL));
    NSLog(@"%s", dispatch_queue_get_label(queue));
/*
com.junteng.myqueue
com.apple.main-thread
com.junteng.myqueue
 */

1.4.3 GCD 各种队列的执行效果

执行方式	并发队列	手动创建的串行队列	主队列
同步（sync）	`没有`开启新线程 `串行`执行任务	`没有`开启新线程 `串行`执行任务	`没有`开启新线程 `串行`执行任务
异步（async）	`有`开启新线程 `并发`执行任务	`有`开启新线程 `串行`执行任务	`没有`开启新线程 `串行`执行任务

// 同步并发
    dispatch_queue_t queue = dispatch_queue_create("myqueue", DISPATCH_QUEUE_CONCURRENT);
    for (int i = 0; i < 5; i++) {
   
        dispatch_sync(queue, ^{
   
            NSLog(@"%@",[NSThread currentThread]);
        });
    }
/*
<NSThread: 0x600001e6cbc0>{number = 1, name = main}
<NSThread: 0x600001e6cbc0>{number = 1, name = main}
<NSThread: 0x600001e6cbc0>{number = 1, name = main}
<NSThread: 0x600001e6cbc0>{number = 1, name = main}
<NSThread: 0x600001e6cbc0>{number = 1, name = main}
 */

// 同步串行（手动创建的串行队列）
    dispatch_queue_t queue = dispatch_queue_create("myqueue", DISPATCH_QUEUE_SERIAL);
    for (int i = 0; i < 5; i++) {
   
        dispatch_sync(queue, ^{
   
            NSLog(@"%@",[NSThread currentThread]);
        });
    }
/*
<NSThread: 0x600001e6cbc0>{number = 1, name = main}
<NSThread: 0x600001e6cbc0>{number = 1, name = main}
<NSThread: 0x600001e6cbc0>{number = 1, name = main}
<NSThread: 0x600001e6cbc0>{number = 1, name = main}
<NSThread: 0x600001e6cbc0>{number = 1, name = main}
 */

// 同步串行（主队列）
    dispatch_queue_t queue = dispatch_queue_create("myqueue", DISPATCH_QUEUE_SERIAL);
    dispatch_async(dispatch_get_main_queue(), ^{
   
        for (int i = 0; i < 5; i++) {
   
            dispatch_sync(queue, ^{
   
                NSLog(@"%@",[NSThread currentThread]);
            });
        }
    });
/*
<NSThread: 0x600001e6cbc0>{number = 1, name = main}
<NSThread: 0x600001e6cbc0>{number = 1, name = main}
<NSThread: 0x600001e6cbc0>{number = 1, name = main}
<NSThread: 0x600001e6cbc0>{number = 1, name = main}
<NSThread: 0x600001e6cbc0>{number = 1, name = main}
 */

// 异步并发：开多个线程，线程数由 GCD 决定
    dispatch_queue_t queue = dispatch_queue_create("myqueue", DISPATCH_QUEUE_SERIAL);
    for (int i = 0; i < 5; i++) {
   
        dispatch_async(queue, ^{
   
            NSLog(@"%@",[NSThread currentThread]);
        });
    }
/*
<NSThread: 0x600001ee53c0>{number = 8, name = (null)}
<NSThread: 0x600001ee57c0>{number = 9, name = (null)}
<NSThread: 0x600001e16a80>{number = 10, name = (null)}
<NSThread: 0x600001e17500>{number = 11, name = (null)}
<NSThread: 0x600001ee53c0>{number = 8, name = (null)}
 */

// 异步串行（手动创建的串行队列）
    dispatch_queue_t queue = dispatch_queue_create("myqueue", DISPATCH_QUEUE_SERIAL);
    for (int i = 0; i < 5; i++) {
   
        dispatch_async(queue, ^{
   
            NSLog(@"%@",[NSThread currentThread]);
        });
    }
/*
<NSThread: 0x600001ee53c0>{number = 8, name = (null)}
<NSThread: 0x600001ee53c0>{number = 8, name = (null)}
<NSThread: 0x600001ee53c0>{number = 8, name = (null)}
<NSThread: 0x600001ee53c0>{number = 8, name = (null)}
<NSThread: 0x600001ee53c0>{number = 8, name = (null)}
 */

// 异步串行（主队列）
    dispatch_queue_t queue = dispatch_get_main_queue();
    for (int i = 0; i < 5; i++) {
   
        dispatch_async(queue, ^{
   
            NSLog(@"%@",[NSThread currentThread]);
        });
    }
/*
<NSThread: 0x600002658680>{number = 1, name = main}
<NSThread: 0x600002658680>{number = 1, name = main}
<NSThread: 0x600002658680>{number = 1, name = main}
<NSThread: 0x600002658680>{number = 1, name = main}
<NSThread: 0x600002658680>{number = 1, name = main}
 */

1.5 死锁

1.5.1 死锁的四大条件

1. 互斥：某种资源一次只允许一个进程访问，即该资源一旦分配给某个进程，其他进程就不能再访问，直到该进程访问结束。
2. 占有且等待：一个进程本身占有资源（一种或多种），同时还有资源未得到满足，正在等待其他进程释放该资源。
3. 不可抢占：别人已经占有了某项资源，你不能因为自己也需要该资源，就去把别人的资源抢过来。
4. 循环等待：存在一个进程链，使得每个进程都占有下一个进程所需的至少一种资源。

1.5.2 GCD 中的死锁

死锁情况：
使用dispatch_sync函数往当前串行队列中添加任务，会卡住当前的串行队列（产生死锁）。
死锁原因：
队列引起的循环等待。
示例1：

/*
 队列的特点：FIFO (First In First Out) 先进先出
 以下将 block（任务2）提交到主队列，主队列将来要取出这个任务放到主线程执行。
 而主队列此时已经有任务，就是执行（viewDidLoad方法），
 所以主队列要想取出 block（任务2），就要等上一个任务（viewDidLoad方法）先执行完，才能取出该任务执行。
 而 dispatch_sync 函数必须执行完 block（任务2）才会返回，才能往下执行代码。
 所以（任务2）要等待（viewDidLoad方法）执行完，（viewDidLoad方法）要等待（任务2）执行完。互相等待，就产生了死锁。
 */
- (void)viewDidLoad {
   
    [super viewDidLoad];

    NSLog(@"执行任务1");

    dispatch_queue_t queue

最低0.47元/天解锁文章

师大小海腾

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
iOS - 多线程（三）：GCD

iOS - 多线程系列文章iOS - 多线程（一）：初识iOS - 多线程（二）：pthread、NSThreadiOS - 多线程（三）：GCDiOS - 多线程（四）：NSOperationiOS - 多线程（五）：线程同步方案1. GCD 初识1.1 GCD 介绍全称是 Grand Central Dispatch，也简称 Dispatch；纯 C 语言，提供了非常多...
复制链接

扫一扫