个人中心
gpt4 book ai didi

iOS 多线程总结之GCD的使用详解

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 30 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章iOS 多线程总结之GCD的使用详解由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

进程与线程 。

进程就是一个应用程序在处理机上的一次执行过程，它是一个动态的概念，而线程是进程中的一部分，进程包含多个线程在运行.

线程是指进程内的一个执行单元,也是进程内的可调度实体. 。

与进程的区别

(1)地址空间:线程是进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址空间;而进程有自己独立的地址空间; (2)资源拥有:进程是资源分配和拥有的单位,同一个进程内的线程共享进程的资源 (3)线程是处理器调度的基本单位,但进程不是. (4)二者均可并发执行. 。

GCD 。

1.什么是GCD?

全称是Grand Central Dispatch，可译为“伟大的中枢调度器” 。

纯C语言，提供了非常多强大的函数 。

2.GCD的优势 。

GCD是苹果公司为多核的并行运算提出的解决方案 。

GCD会自动利用更多的CPU内核（比如双核、四核） 。

GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程） 。

程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码 。

队列与任务 。

1.队列主要包含三种：主线程队列、并行队列、串行队列 。

2.任务主要包含两种：异步任务和同步任务 。

多线程执行过程就是把任务放在队列中去执行的过程 。

(在计算机操作系统中对异步和同步有很深入的概念和定义，并影响到计算机系统有单线程到多线程的过渡发展，其中牵涉到线程切换、时间片等概念。但在GCD这里我们只做大致使用区别) 。

队列:

  1. 并行队列 ：在队列中的多个任务（线程） 同时执行 （不按顺序执行）
  2. 串行队列： 在队列中的多个任务（线程）排队 依次执行（按顺序执行）

任务

同步（sync） 和 异步（async） 的主要区别在于会不会阻塞当前线程，直到 Block 中的任务执行完毕！ 。

如果是 同步（sync） 操作，它会阻塞当前线程并等待 Block 中的任务执行完毕，然后当前线程才会继续往下运行.

如果是 异步（async）操作，当前线程会直接往下执行，它不会阻塞当前线程.

3.队列的创建方法 。

可以使用dispatch_queue_create来创建对象，需要传入两个参数，第一个参数表示队列的唯一标识符，用于DEBUG，可为空；第二个参数用来识别是串行队列还是并行队列。DISPATCH_QUEUE_SERIAL表示串行队列，DISPATCH_QUEUE_CONCURRENT表示并行队列.

?
1
2
3
4
// 串行队列的创建方法
dispatch_queue_t queue= dispatch_queue_create( "test.queue" , DISPATCH_QUEUE_SERIAL);
// 并行队列的创建方法
dispatch_queue_t queue= dispatch_queue_create( "test.queue" , DISPATCH_QUEUE_CONCURRENT);

对于并行队列，还可以使用dispatch_get_global_queue来创建全局并行队列。GCD默认提供了全局的并行队列，需要传入两个参数。第一个参数表示队列优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用，用0即可.

4.任务的创建方法 。

?
1
2
3
4
5
6
7
8
// 同步执行任务创建方法
dispatch_sync(queue, ^{
NSLog(@ "%@" ,[NSThread currentThread]); // 这里放任务代码
});
// 异步执行任务创建方法
dispatch_async(queue, ^{
NSLog(@ "%@" ,[NSThread currentThread]); // 这里放任务代码
});

虽然使用GCD只需两步，但是既然我们有两种队列，两种任务执行方式，那么我们就有了四种不同的组合方式。这四种不同的组合方式是 。

1.并行队列 + 同步执行 2.并行队列 + 异步执行 3.串行队列 + 同步执行 4.串行队列 + 异步执行 。

5.GCD的基本使用 。

并行队列+同步执行 。

不会开启新线程，执行完一个任务，再执行下一个任务 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
-( void ) syncConcurrent{
NSLog(@ "syncConcurrent---begin" );
dispatch_queue_t queue= dispatch_queue_create( "test.queue" , DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue, ^{
   for ( int i = 0; i < 2; ++i) {
     NSLog(@ "1------%@" ,[NSThread currentThread]);
   }
});
dispatch_sync(queue, ^{
   for ( int i = 0; i < 2; ++i) {
     NSLog(@ "2------%@" ,[NSThread currentThread]);
   }
});
dispatch_sync(queue, ^{
   for ( int i = 0; i < 2; ++i) {
     NSLog(@ "3------%@" ,[NSThread currentThread]);
   }
});
 
NSLog(@ "syncConcurrent---end" );
  }

并行队列 + 异步执行 。

可同时开启多线程，任务交替执行 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
- ( void ) asyncConcurrent
{
NSLog(@ "asyncConcurrent---begin" );
 
dispatch_queue_t queue= dispatch_queue_create( "test.queue" , DISPATCH_QUEUE_CONCURRENT);
 
dispatch_async(queue, ^{
  for ( int i = 0; i < 2; ++i) {
    NSLog(@ "1------%@" ,[NSThread currentThread]);
  }
});
dispatch_async(queue, ^{
  for ( int i = 0; i < 2; ++i) {
    NSLog(@ "2------%@" ,[NSThread currentThread]);
  }
});
dispatch_async(queue, ^{
  for ( int i = 0; i < 2; ++i) {
    NSLog(@ "3------%@" ,[NSThread currentThread]);
  }
});
 
NSLog(@ "asyncConcurrent---end" );
}

串行队列 + 同步执行 。

不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
- ( void ) syncSerial
{
NSLog(@ "syncSerial---begin" );
 
dispatch_queue_t queue = dispatch_queue_create( "test.queue" , DISPATCH_QUEUE_SERIAL);
 
  dispatch_sync(queue, ^{
  for ( int i = 0; i < 2; ++i) {
    NSLog(@ "1------%@" ,[NSThread currentThread]);
  }
}); 
dispatch_sync(queue, ^{
  for ( int i = 0; i < 2; ++i) {
    NSLog(@ "2------%@" ,[NSThread currentThread]);
  }
});
dispatch_sync(queue, ^{
  for ( int i = 0; i < 2; ++i) {
    NSLog(@ "3------%@" ,[NSThread currentThread]);
  }
});
 
NSLog(@ "syncSerial---end" );
}

串行队列 + 异步执行 。

会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
- ( void ) asyncSerial
{
NSLog(@ "asyncSerial---begin" );
 
dispatch_queue_t queue = dispatch_queue_create( "test.queue" , DISPATCH_QUEUE_SERIAL);
 
dispatch_async(queue, ^{
  for ( int i = 0; i < 2; ++i) {
    NSLog(@ "1------%@" ,[NSThread currentThread]);
  }
}); 
dispatch_async(queue, ^{
  for ( int i = 0; i < 2; ++i) {
    NSLog(@ "2------%@" ,[NSThread currentThread]);
  }
});
dispatch_async(queue, ^{
  for ( int i = 0; i < 2; ++i) {
    NSLog(@ "3------%@" ,[NSThread currentThread]);
  }
});
 
NSLog(@ "asyncSerial---end" );
}

主队列 + 同步执行 。

互等卡住不可行(在主线程中调用)，会出现死锁 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
- ( void )syncMain
{
NSLog(@ "syncMain---begin" );
 
dispatch_queue_t queue = dispatch_get_main_queue();
 
dispatch_sync(queue, ^{
for ( int i = 0; i < 2; ++i) {
   NSLog(@ "1------%@" ,[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for ( int i = 0; i < 2; ++i) {
   NSLog(@ "2------%@" ,[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for ( int i = 0; i < 2; ++i) {
   NSLog(@ "3------%@" ,[NSThread currentThread]);
}
}); 
 
NSLog(@ "syncMain---end" );
}

这是因为我们在主线程中执行这段代码。我们把任务放到了主队列中，也就是放到了主线程的队列中。而同步执行有个特点，就是对于任务是立马执行的。那么当我们把第一个任务放进主队列中，它就会立马执行。但是主线程现在正在处理syncMain方法，所以任务需要等syncMain执行完才能执行。而syncMain执行到第一个任务的时候，又要等第一个任务执行完才能往下执行第二个和第三个任务.

那么，现在的情况就是syncMain方法和第一个任务都在等对方执行完毕。这样大家互相等待，所以就卡住了，所以我们的任务执行不了.

主队列 + 异步执行 。

只在主线程中执行任务，执行完一个任务，再执行下一个任务 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
- ( void )asyncMain
{
  NSLog(@ "asyncMain---begin" );
 
  dispatch_queue_t queue = dispatch_get_main_queue();
 
  dispatch_async(queue, ^{
  for ( int i = 0; i < 2; ++i) {
    NSLog(@ "1------%@" ,[NSThread currentThread]);
  }
}); 
  dispatch_async(queue, ^{
  for ( int i = 0; i < 2; ++i) {
    NSLog(@ "2------%@" ,[NSThread currentThread]);
  }
  });
  dispatch_async(queue, ^{
  for ( int i = 0; i < 2; ++i) {
    NSLog(@ "3------%@" ,[NSThread currentThread]);
  }
  });
 
  NSLog(@ "asyncMain---end" );
  }

GCD的队列组 dispatch_group 。

有时候我们会有这样的需求：分别异步执行2个耗时操作，然后当2个耗时操作都执行完毕后再回到主线程执行操作。这时候我们可以用到GCD的队列组.

我们可以先把任务放到队列中，然后将队列放入队列组中.

调用队列组的dispatch_group_notify回到主线程执行操作.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
dispatch_group_t group = dispatch_group_create();
 
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 执行1个耗时的异步操作
});
 
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  // 执行1个耗时的异步操作
  });
 
  dispatch_group_notify(group, dispatch_get_main_queue(), ^{
  // 等前面的异步操作都执行完毕后，回到主线程...
  });

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我.

原文链接：http://www.jianshu.com/p/cb5593cb11f1?utm_source=tuicool&utm_medium=referral 。

最后此篇关于iOS 多线程总结之GCD的使用详解的文章就讲到这里了,如果你想了解更多关于iOS 多线程总结之GCD的使用详解的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

30 4 0
文章推荐： Windows平台配置5.7版本+MySQL数据库服务
文章推荐： 2021可爱女生头像抱着猫咪高清大图 别说谁变了你拦不住时间
文章推荐： 四人卡通又不失沙雕的微信团头 这世界从不缺让人心动的新鲜感
文章推荐： CentOS 7中MySQL连接数被限制为214个的解决方法
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com