GCD在iOS多线程中的应用-优快云博客

本文详细介绍了GCD在iOS多线程编程中的使用方法，包括基本概念、特性、不同队列与任务执行方式的组合效果，以及如何通过GCD实现线程间的通讯、延时执行、一次性代码执行等功能。

2019独角兽企业重金招聘Python工程师标准>>>

IOS 多线程(中)

GCD

GCD 简介

Grand Central Dispatch (GCD) 是Apple开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并行任务。
GCD 特点
- GCD可用于多核的并行运算
- GCD会自动利用更多的CPU内核（比如双核、四核）
- GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
- 程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码
任务与队列

任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行和异步执行。两者的主要区别是：是否具备开启新线程的能力。
- 同步执行（sync）：只能在当前线程中执行任务，不具备开启新线程的能力
- 异步执行（async）：可以在新的线程中执行任务，具备开启新线程的能力
队列：这里的队列指任务队列，即用来存放任务的队列。队列是一种特殊的线性表，采用FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。在GCD中有两种队列：串行队列和并发队列。
- 并发队列（Concurrent Dispatch Queue）：可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
- 串行队列（Serial Dispatch Queue）：让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）
GCD的使用步骤

GCD的使用步骤其实很简单，只有两步。

1、创建一个队列（串行队列或并发队列）

2、将任务添加到队列中，然后系统就会根据任务类型执行任务（同步执行或异步执行）下边来看看队列的创建方法和任务的创建方法。

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

DISPATCH_QUEUE_SERIAL表示串行队列，DISPATCH_QUEUE_CONCURRENT表示并发队列。
```
	// 串行队列的创建方法
```

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即可。

任务的创建方法:

```
// 同步执行任务创建方法

dispatch_sync(queue, ^{ NSLog(@"%@",[NSThread currentThread]); // 这里放任务代码 }); // 异步执行任务创建方法 dispatch_async(queue, ^{ NSLog(@"%@",[NSThread currentThread]); // 这里放任务代码 });

```

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


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

实际上，我们还有一种特殊队列是主队列，那样就有六种不同的组合方式了。
>1. 主队列 + 同步执行
>2. 主队列 + 异步执行

GCD的基本使用
- 并发队列 + 同步执行

        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]);
        }
    });

从上至下，一个一个依次执行，

* 并发队列 + 异步执行

- (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");
	}

输出结果：

输出结果： 2016-09-03 19:27:31.503 GCD[11595:1901548] asyncConcurrent---begin 2016-09-03 19:27:31.504 GCD[11595:1901548] asyncConcurrent---end 2016-09-03 19:27:31.504 GCD[11595:1901626] 1------<NSThread: 0x7f8309c22080>{number = 2, name = (null)} 2016-09-03 19:27:31.504 GCD[11595:1901625] 2------<NSThread: 0x7f8309f0b790>{number = 4, name = (null)} 2016-09-03 19:27:31.504 GCD[11595:1901855] 3------<NSThread: 0x7f8309e1a950>{number = 3, name = (null)} 2016-09-03 19:27:31.504 GCD[11595:1901626] 1------<NSThread: 0x7f8309c22080>{number = 2, name = (null)} 2016-09-03 19:27:31.504 GCD[11595:1901625] 2------<NSThread: 0x7f8309f0b790>{number = 4, name = (null)} 2016-09-03 19:27:31.505 GCD[11595:1901855] 3------<NSThread: 0x7f8309e1a950>{number = 3, name = (null)}

在并发队列 + 异步执行中可以看出，除了主线程，又开启了3个线程，并且任务是交替着同时执行的。

另一方面可以看出，所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的。说明任务不是马上执行，而是将所有任务添加到队列之后才开始异步执行。

串行队列 + 同步执行

不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务
```
	- (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");
	}
```
输出结果：

2016-09-03 19:29:00.066 GCD[11622:1903904] syncSerial---begin 2016-09-03 19:29:00.067 GCD[11622:1903904] 1------<NSThread: 0x7fa2e9f00980>{number = 1, name = main} 2016-09-03 19:29:00.067 GCD[11622:1903904] 1------<NSThread: 0x7fa2e9f00980>{number = 1, name = main} 2016-09-03 19:29:00.067 GCD[11622:1903904] 2------<NSThread: 0x7fa2e9f00980>{number = 1, name = main} 2016-09-03 19:29:00.067 GCD[11622:1903904] 2------<NSThread: 0x7fa2e9f00980>{number = 1, name = main} 2016-09-03 19:29:00.067 GCD[11622:1903904] 3------<NSThread: 0x7fa2e9f00980>{number = 1, name = main} 2016-09-03 19:29:00.068 GCD[11622:1903904] 3------<NSThread: 0x7fa2e9f00980>{number = 1, name = main} 2016-09-03 19:29:00.068 GCD[11622:1903904] syncSerial---end

立即执行、所以按顺序一个一个执行。
- 串行队列 + 异步执行

	- (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");
	}
	```
输出结果
>2016-09-03 19:30:08.363 GCD[11648:1905817] asyncSerial---begin
	
>2016-09-03 19:30:08.364 GCD[11648:1905817] asyncSerial---end
	
>2016-09-03 19:30:08.364 GCD[11648:1905895] 1------<NSThread: 0x7fb548c0e390>{number = 2, name = (null)}
	
>2016-09-03 19:30:08.364 GCD[11648:1905895] 1------<NSThread: 0x7fb548c0e390>{number = 2, name = (null)}
	
>2016-09-03 19:30:08.364 GCD[11648:1905895] 2------<NSThread: 0x7fb548c0e390>{number = 2, name = (null)}
	
>2016-09-03 19:30:08.364 GCD[11648:1905895] 2------<NSThread: 0x7fb548c0e390>{number = 2, name = (null)}
	
>2016-09-03 19:30:08.365 GCD[11648:1905895] 3------<NSThread: 0x7fb548c0e390>{number = 2, name = (null)}
	
>2016-09-03 19:30:08.365 GCD[11648:1905895] 3------<NSThread: 0x7fb548c0e390>{number = 2, name = (null)}
	
   在串行队列 + 异步执行可以看到，开启了一条新线程，但是任务还是串行，所以任务是一个一个执行。
	
   一方面可以看出，所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的。说明任务不是马上执行，而是将所有任务添加到队列之后才开始同步执行。
		
6. 主队列
	
	主队列是GCD自带的一种特殊的串行队列,所有放在主队列中的任务，都会放到主线程中执行。由于UI刷新只能在主线程中执行，这个队列对于界面刷新尤其重要
	
	可使用```dispatch_get_main_queue```()获得主队列
	
	* 主队列+同步

- (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");
}

输出结果
>2016-09-03 19:32:15.356 GCD[11670:1908306] syncMain---begin
	
  这时候，我们惊奇的发现，在主线程中使用主队列 + 同步执行，任务不再执行了，而且syncMain---end也没有打印。这是为什么呢？

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

  那么，现在的情况就是syncMain方法和第一个任务都在等对方执行完毕。这样大家互相等待，所以就卡住了，所以我们的任务执行不了，而且syncMain---end也没有打印。
	
* 主队列 + 异步执行

- (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");
}

	
输出结果：
>2016-09-03 19:33:54.995 GCD[11706:1911313] asyncMain---begin
2016-09-03 19:33:54.996 GCD[11706:1911313] asyncMain---end
2016-09-03 19:33:54.996 GCD[11706:1911313] 1------<NSThread: 0x7fb623d015e0>{number = 1, name = main}
2016-09-03 19:33:54.997 GCD[11706:1911313] 1------<NSThread: 0x7fb623d015e0>{number = 1, name = main}
2016-09-03 19:33:54.997 GCD[11706:1911313] 2------<NSThread: 0x7fb623d015e0>{number = 1, name = main}
2016-09-03 19:33:54.997 GCD[11706:1911313] 2------<NSThread: 0x7fb623d015e0>{number = 1, name = main}
2016-09-03 19:33:54.997 GCD[11706:1911313] 3------<NSThread: 0x7fb623d015e0>{number = 1, name = main}
2016-09-03 19:33:54.997 GCD[11706:1911313] 3------<NSThread: 0x7fb623d015e0>{number = 1, name = main}

主队列也是串行队列，所以一个一个的处理下去，因为是异步线程，所以不会立即执行（要是理解了上面的，也就不难理解这里了）
	 
7. GCD线程之间的通讯（最常用的喔！）	

在iOS开发过程中，我们一般在主线程里边进行UI刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ for (int i = 0; i < 2; ++i) { NSLog(@"1------%@",[NSThread currentThread]); }

    // 回到主线程
    dispatch_async(dispatch_get_main_queue(), ^{
    	// 我们经常会在这里做一些ui刷新操作
        NSLog(@"2-------%@",[NSThread currentThread]);
    });
});


```

输出结果： 2016-09-03 19:34:59.165 GCD[11728:1913039] 1------<NSThread: 0x7f8319c06820>{number = 2, name = (null)} 2016-09-03 19:34:59.166 GCD[11728:1913039] 1------<NSThread: 0x7f8319c06820>{number = 2, name = (null)} 2016-09-03 19:34:59.166 GCD[11728:1912961] 2-------<NSThread: 0x7f8319e00560>{number = 1, name = main}

GCD的其他方法
- GCD的栅栏方法
  
  我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。
```
	- (void)barrier
	{
	    dispatch_queue_t queue = dispatch_queue_create("12312312", DISPATCH_QUEUE_CONCURRENT);

	    dispatch_async(queue, ^{
	        NSLog(@"----1-----%@", [NSThread currentThread]);
	    });
	    dispatch_async(queue, ^{
	        NSLog(@"----2-----%@", [NSThread currentThread]);
	    });

	    dispatch_barrier_async(queue, ^{
	        NSLog(@"----barrier-----%@", [NSThread currentThread]);
	    });

	    dispatch_async(queue, ^{
	        NSLog(@"----3-----%@", [NSThread currentThread]);
	    });
	    dispatch_async(queue, ^{
	        NSLog(@"----4-----%@", [NSThread currentThread]);
	    });
	}
```
  输出结果：
  
  2016-09-03 19:35:51.271 GCD[11750:1914724] ----1-----<NSThread: 0x7fb1826047b0>{number = 2, name = (null)}
  
  2016-09-03 19:35:51.272 GCD[11750:1914722] ----2-----<NSThread: 0x7fb182423fd0>{number = 3, name = (null)}
  
  2016-09-03 19:35:51.272 GCD[11750:1914722] ----barrier-----<NSThread: 0x7fb182423fd0>{number = 3, name = (null)}
  
  2016-09-03 19:35:51.273 GCD[11750:1914722] ----3-----<NSThread: 0x7fb182423fd0>{number = 3, name = (null)}
  
  2016-09-03 19:35:51.273 GCD[11750:1914724] ----4-----<NSThread: 0x7fb1826047b0>{number = 2, name = (null)}
  
  可以看出在执行完栅栏前面的操作之后，才执行栅栏操作，最后再执行栅栏后边的操作。
- GCD的延时执行方法
  
  当我们需要延迟执行一段代码时，就需要用到GCD的dispatch_after方法。
```
	dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
	    // 2秒后异步执行这里的代码...
	   NSLog(@"run-----");
	});
```
- GCD的一次性代码(只执行一次)
  
  我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了GCD的dispatch_once方法。使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次。
```
	static dispatch_once_t onceToken;
```

dispatch_once(&onceToken, ^{ // 只执行1次的代码(这里面默认是线程安全的) }); ```

* GCD的快速迭代方法

	通常我们会用for循环遍历，但是GCD给我们提供了快速迭代的方法```dispatch_apply```，使我们可以同时遍历。比如说遍历0~5这6个数字，for循环的做法是每次取出一个元素，逐个遍历。```dispatch_apply```可以同时遍历多个数字。
	
	```
	dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

	dispatch_apply(6, queue, ^(size_t index) {
	    NSLog(@"%zd------%@",index, [NSThread currentThread]);
	});
	```
	
	输出结果：
	>2016-09-03 19:37:02.250 GCD[11764:1915764] 1------<NSThread: 0x7fac9a7029e0>{number = 1, name = main}
	
	>2016-09-03 19:37:02.250 GCD[11764:1915885] 0------<NSThread: 0x7fac9a614bd0>{number = 2, name = (null)}
	
	>2016-09-03 19:37:02.250 GCD[11764:1915886] 2------<NSThread: 0x7fac9a542b20>{number = 3, name = (null)}
	
	>2016-09-03 19:37:02.251 GCD[11764:1915764] 4------<NSThread: 0x7fac9a7029e0>{number = 1, name = main}
	
	>2016-09-03 19:37:02.250 GCD[11764:1915884] 3------<NSThread: 0x7fac9a76ca10>{number = 4, name = (null)}
	
	>2016-09-03 19:37:02.251 GCD[11764:1915885] 5------<NSThread: 0x7fac9a614bd0>{number = 2, name = (null)}
	
	从输出结果中前边的时间中可以看出，几乎是同时遍历的。
	
* GCD的队列组

有时候我们会有这样的需求：分别异步执行2个耗时操作，然后当2个耗时操作都执行完毕后再回到主线程执行操作。这时候我们可以用到GCD的队列组。
比如我们同时下载十个文件，等这十个文件下载完再提示成功，我们就可以把这十个下载放入group中

* 我们可以先把任务放到队列中，然后将队列放入队列组中。调用队列组的```dispatch_group_notify```回到主线程执行操作。

* 我们可以先把任务放到队列中，然后将队列放入队列组中。调用队列组的```dispatch_group_notify```回到主线程执行操作。

```
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(), ^{
    // 等前面的异步操作都执行完毕后，回到主线程...
});
```

上一篇IOS 多线程(上)

下一篇IOS 多线程(下)

转载于:https://my.oschina.net/KJhulinhua/blog/1031178