完整详细的说明GCD列（一）dispatch_async;dispatch_sync;dispatch_async_f;dispatch_sync_f

2022-03-10 13:17:19

为什么要写这个系列，由于百度了一下。我们正在寻找一个非常比较片面的Blog。抄来抄去，写作是很粗糙。

所以，我想写这个系列，尝试记录官方网站GCD强大的全功能的表达。为了方便他们，也方便他人，假设有发现一个问题，欢迎

该教程程序：完整的看过GCD的官方文档之后。我实在想不出来怎样用一篇文章具体完整的写出来如此多的功能。

所以。决定开一个专栏来写这个教程。

计划8篇文章，分别介绍各种功能，每种功能会附上简单完整的演示样例代码。

最后

的一篇文章会进行总结。总结出GCD的经典使用场景。源码仅仅提供Swift版本号。由于要上班，计划一个月内完毕。

每周两篇。

原创Blog，转载请注明出处

这个专栏地址

http://blog.csdn.net/column/details/swift-gcd.html

GCD

全称：Grand Central Dispatch

简单介绍：GCD是对多线程、多核开发较完整的封装。在使用GCD的时候，系统会自己主动依据CPU使用情况进行调度，所以GCD是

一个简单易用，可是效果非常好地多线程多核开发工具。

要注意的地方：

1、慎用fork()函数（不是十分清楚流程不要用）

2、GCD是C语言级别的API，所以不会抓到异常。在一个提交到GCD的任务完毕之前，应当处理完异常。

教程一

教程一涵盖了

1、GCD全局队列的四个优先级

2、几种本文使用到的GCD类型

3、dispatch_async/dispatch_async_f

4、dispatch_sync/dispatch_sync_f

一、概念与类型

对于GCD来说。全部的运行都放到队列中(queue)。队列的特点是FIFO（先提交的先运行）。

GCD的队列分为几种，主队列（main）,全局队列(global),用户创建队列(create)

对于全局队列，默认有四个，分为四个优先级

#define DISPATCH_QUEUE_PRIORITY_HIGH         2

#define DISPATCH_QUEUE_PRIORITY_DEFAULT      0

#define DISPATCH_QUEUE_PRIORITY_LOW          (-2)

#define DISPATCH_QUEUE_PRIORITY_BACKGROUND   INT16_MIN

DISPATCH_QUEUE_PRIORITY_HIGH :优先级最高。在default,和low之前运行

DISPATCH_QUEUE_PRIORITY_DEFAULT 默认优先级。在low之前。在high之后

DISPATCH_QUEUE_PRIORITY_LOW 在high和default后运行

DISPATCH_QUEUE_PRIORITY_BACKGROUND:提交到这个队列的任务会在high优先级的任务和已经提交到background队列的运行完后运行。

官方文档：(the queue is scheduled for execution after all high priority queues have been scheduled and the system runs items on a thread whose priority is set for background status.)

几种使用到的类型

typealias dispatch_queue_t = NSObject //轻量级的用来描写叙述运行任务的队列

typealias dispatch_block_t = () -> Void //队列运行的闭包(Objective C中的block)

几个概念

异步提交的任务立马返回，在后台队列中运行

同步提交的任务在运行完毕后才会返回

并行运行（全局队列）提交到一个队列的任务，比方提交了任务1和任务2，在任务1開始运行，而且没有运行完成时候，任务2就能够開始运行。

串行运行（用户创建队列）提交到一个队列中的任务。比方提交了任务1和任务2。仅仅有任务1结束后。任务2才可运行

注意：提交到队列中的任务是串行运行，还是并行运行由队列本身决定。

二、演示样例具体解释

func dispatch_async(_ queue: dispatch_queue_t!,

                  _ block: dispatch_block_t!)

參数：

queue 提交到的队列，队列的类型决定了是串行还是并行运行队列中的任务

block 运行的闭包

func dispatch_async_f(_ queue: dispatch_queue_t!,

                    _ context: UnsafeMutablePointer<Void>,

                    _ work: dispatch_function_t)

參数

queue 提交到的队列，队列的类型决定了是串行还是并行运行队列中的任务

context 传递给work的參数

work 运行的函数(C语言函数)

dispatch_sync 和 dispatch_sync的參数和上述相应一致，所以不再列出

总得来说带有后缀_f(比方dispatch_sync_f，dispatch_after_f)就是提交给队列一个C语言函数，由于极少用到这样的形式，这里仅给出一个简单样例。后面的涉及到_f的都略过。

1、dispatch_async/dispatch_sync

功能：提交到队列中异步/同步运行

本演示样例：下载一张图片，图片完成下载后通知UI改变

注意：要改变UI必须在主队列上运行

这里用到了一个获取全局队列的函数

func dispatch_get_global_queue(_ identifier: Int,

                             _ flags: UInt) -> dispatch_queue_t!

这个函数的第一个參数是队列的优先级，第二个參数尚没有意义。直接写0就能够了。

创建一个基于单页面的Swiftproject，然后在ViewController.swift中。

class ViewController: UIViewController{

    var imageview = UIImageView(frame: CGRectMake(40,40,200,200))

    override func viewDidLoad(){

        super.viewDidLoad()

        imageview.contentMode = UIViewContentMode.ScaleAspectFit

        self.view.addSubview(imageview)

        let url = "http://f.hiphotos.baidu.com/image/pic/item/e1fe9925bc315c60191d32308fb1cb1348547760.jpg"

        let imageURL = NSURL(string:url)

	var globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)

	dispatch_async(globalQueueDefault){

		var imageData = NSData(contentsOfURL:imageURL!)

		var image = UIImage(data:imageData!)

		if let successfulImage = image{

			sleep(2)

			dispatch_async(dispatch_get_main_queue()){

				self.imageview.image = successfulImage

			}

		}

	}

    }

    override func didReceiveMemoryWarning(){

        super.didReceiveMemoryWarning()

    }

}

运行。观察下效果：view立马加载，然后过一段时间，图片下载完了。UI改变

然后，我们观察dispatch_sync

仅仅须要改动这一行就可以

dispatch_sync(globalQueueDefault,0){

运行。观察下效果：view加载非常慢，可是在加载的时候，图片下载完了。

UI已经改变。能够打在这一行打断点，会发现异步运行会立马返回，同步运行会等待运行结束后返回。

所以。当我们有一件很耗时的事情。放到后台队列中去做，等做完了通知UI改变。是不会堵塞UI，减少用户体验的。

2、dispatch_async_f/dispatch_sync_f

简单的实例。把一个C函数提交给队列

首先，建立一个基于单页面的swiftproject,命名为testForCSDN，然后再新建一个C语言文件，命名为hwcText->点击包括头文件->点击包括Bridging-Header.h

这样。project里多了三个文件

hwcTest.c

hwcTest.h

testForCSDN-Bridging-Header.h

附上完整的代码

testForCSDN-Bridging-Header.h

#import "hwcTest.h"

hwcTest.h

#include <stdio.h>

#include <unistd.h>

typedef void (*hwcTestForGCD)(void*);

hwcTestForGCD getFuncPointer();

hwcTest.c

#include "hwcTest.h"

void realFunction(void *input){

	for(int i = 0;i < 5;i++){

		printf("%d\n",i);

		sleep(1);

	}

}

hwcTestForGCD getFuncPointer(){

	return realFunction;

}

ViewController.swift

class ViewController: UIViewController{

    var imageview = UIImageView(frame: CGRectMake(40,40,200,200))

    override func viewDidLoad(){

        super.viewDidLoad()

      	var globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)

	dispatch_async_f(globalQueueDefault,nil,getFuncPointer())

	println("dispatch is over")

    }

    override func didReceiveMemoryWarning(){

        super.didReceiveMemoryWarning()

    }

}

然后运行，会发现输出

0

dispatch is over

1

2

3

4

然后，我们相同改成dispatch_sync后运行，发现输出

0

1

2

3

4

5

dispatch is over

这里更能体会到了，什么是同步，什么是异步了吧。

三、理解下并行队列和串行队列

使用一或者二中的project都能够，改动ViewController.swft中的代码就能够

这里用到了一个函数

func dispatch_queue_create(_ label: UnsafePointer<Int8>,

                         _ attr: dispatch_queue_attr_t!) -> dispatch_queue_t!

參数

label String类型的队列标示符。通常取做com.companyname.productname.functionname

attr
两种类型。

DISPATCH_QUEUE_SERIAL创建一个顺序运行队列。 DISPATCH_QUEUE_CONCURRENT创建同一时候运行队列

ViewController的完整代码，这里提交两个任务，通过输出来推断是并行队列，还是串行队列

class ViewController: UIViewController{

    var imageview = UIImageView(frame: CGRectMake(40,40,200,200))

    override func viewDidLoad(){

        super.viewDidLoad()

	dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)){

		for var i = 0;i < 5;i++ {

			NSLog("First task:%d",i)

			sleep(1)

		}

	}

	dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)){

		for var j = 0;j < 5;j++ {

			NSLog("Second task:%d",j)

			sleep(1)

		}

	}

	println("dispatch is over")

    }

    override func didReceiveMemoryWarning(){

        super.didReceiveMemoryWarning()

    }

}

这里运行输出为：

First task:0

Second task:0

First task:1

Second task:1

First task:2

Second task:2

First task:3

Second task:3

First task:4

Second task:4

这段代码运行时间4.03s

然后。我们使用串行运行的队列

class ViewController: UIViewController{

    var imageview = UIImageView(frame: CGRectMake(40,40,200,200))

    override func viewDidLoad(){

        super.viewDidLoad()

	var serialQueue =  dispatch_queue_create(label: 

"com.test.helloHwc",attr:DISPATCH_QUEUE_SERIAL)

	dispatch_async(serialQueue){

		for var i = 0;i < 5;i++ {

			NSLog("First task:%d",i)

			sleep(1)

		}

	}

	dispatch_async(serialQueue){

		for var j = 0;j < 5;j++ {

			NSLog("Second task:%d",j)

                        sleep(1)

		}

	}

	println("dispatch is over")

    }

    override func didReceiveMemoryWarning(){

        super.didReceiveMemoryWarning()

    }

}

这里输出为

First task:0

First task:1

First task:2

First task:3

First task:4

Second task:0

Second task:1

Second task:2

Second task:3

Second task:4

这段代码运行时间8.06秒

看出来并行和串行运行的区别了吧。

所以，记住一点，把过程不相关的任务。提交到并行的队列中会显著提高效率

下一篇估计更新时间，本周末

BTY：假设图片下载失败。可能由于时间的原因。那张图片从server上删除了，自己找一个URL就可以

原图

码农公寓

相关文章