回到LocationDetailsViewController.swift，当用户点击done按钮后关闭这个界面。
我们来做个新的挑战：不要立即关闭这个界面，如果HUD界面还没有消失的话，界面就已经被关闭了，那么会显现非常蠢。
打开LocationDetailsViewController.swift，添加这一行：
import Dispatch
这是一个中央调度框架，Grand Central Dispatch，简写为GCD。这是一个非常便利，但是比较底层的库，用于处理异步任务。用这种异步的任务通知app等待几秒钟再合适不过了。
在done()方法的底部添加以下代码：
let delayInSeconds = 0.6
DispatchQueue.main.asyncAfter(deadline: .now() + delayInSeconds, execute:
{
self.dismiss(animated: true, completion: nil)
})
这部分代码的作用是在0.6秒后关闭Tag Location界面。
核心部分是DispatchQueue.main.asyncAfter()。这个函数的最后一个参数是一个闭包。在这个闭包内部你通知视图控制器把自己关闭掉。并且这个行为不是立即发生的。这就是闭包的特点，函数内的其他代码都是逐行顺序执行的，而闭包内的则不会。
DispatchQueue.main.asyncAfter()从.now() + delayInSeconds中得到延迟的时间，在时间到达后，执行闭包内的代码。
⚠️：我花了些时间来微调时间参数，HUD的完全消失大概需要0.3秒，但是在HUD消失的同时立即关闭当前界面，给用户的感知也不好，所以经过多次调整，我把延迟的时间确定为0.6秒。
运行app，点击Done按钮，观察一下效果，一切都感觉非常平滑。
不知道你感觉怎么样，我的感觉是GCD这部分代码把整个done方法弄的乱糟糟的。让我们重新整理下代码。
添加一个新的Swift文件，命名为Functions.swift。
把下面的内容都放到新的文件中去：
import Foundation
import Dispatch
func afterDelay(_ seconds: Double, closure: @escaping () -> ()) {
DispatchQueue.main.asyncAfter(deadline: .now() + seconds,execute: closure)
}
这些代码和刚才done方法中的非常相似，只是被单独放到了一个新的函数中，afterDelay()。这是一个自由函数，不是对象中的方法，它可以在你的所有代码中随意使用。
我们来看看这个方法中的第二个参数，名字叫做closure。它的类型是 () -> ()。看起来很奇怪，它的意思是，这个参数的值是一个没有参数及返回值的闭包。完整的定义是像下面这个样子：
(parameter list) -> return type
在我们的应用中，参数和返回值都是空，记做()。也可以写作Void -> Void，但是我比较喜欢前一种。
所以，无论何时，你在参数中看到->这个符号，你就知道这个参数是一个闭包。
afterDelay()将这个闭包传递给DispatchQueue.main.asyncAfter()。
@escaping的意思是，闭包中的代码不要立即执行，swift看到这个符号时，就知道应该将闭包中的代码保存起来，在适当的时候执行。
也许你想知道，为什么我们要费这么大事，接下来我就为你展示这一点。
打开LocationDetailsViewController.swift，将done方法修改为：
@IBAction func done() {
let hudView = HudView.hud(inView: navigationController!.view,animated: true)
hudView.text = "Tagged"
afterDelay(0.6, closure: {
self.dismiss(animated: true, completion: nil)
})
}
这就是swift的魅力所在，只要稍微看一下，就基本可以明白代码的意思。
通过将繁琐的GCD代码移到新的函数中，done方法的可读性大大的增加了。（原文啰嗦了很多，大意就是这个，本书的作者是我见过的写技术文档中最喜欢卖弄文采的一个，堪称代码界的郭小四。）
注意一下，因为关闭界面的代码位于闭包中，所以你必须使用self关键字，就像你看到的这样：
afterDelay(0.6) {
self.dismiss(animated: true, completion: nil)
}
看起来有点无法理解是吗，闭包被放到参数的外面去了，Swift有个特性，如果一个函数或者方法的最后一个参数是个闭包，那么可以把这个闭包写到参数外面，紧随其后，就像上面那样。
顺便说一下，你可以把LocationDetailsViewController.swift文件中的import Dispatch这一句删掉了。
运行app，看看效果是否一致。
值类型和引用类型
Swift中的变量分为值类型和引用类型，它们的规则也是不同的。
从类中生成的对象都是引用类型的。其他的诸如：Int, Bool, Float and Double, String, Array，Dictionary以及enums都是值类型。
那么它们具体有些什么不同呢？
当你声明一个类型为Int或者CLLocationCoordinate2D的变量时，它们就是值类型，编译器会把它们的值存储到一小块内存中保存下来。对于Int而言是8个字节，CLLocationCoordinate2D是16个字节。
引用类型的变量在这一点上并无不同，比如你创建一个UILabel outlet，编译器同样是用8个字节存储它，但是UILabel中可能存在多行文本，8个字节明显不够用。
当你把值存储到这两种类型的变量中时，它们的工作原理分别是这样的：
值1337被直接存储在变量number的内存中，但是变量label的值是一个奇怪的数字。明显它看起来和text label没什么关系。这个数字并不是实际的UILabel对象，而是指向UILable对象的内存地址。这就是引用类型。
内存中的每一个字节都有独一无二的地址，这里地址58741002引用UILabel对象在内存中的第一个字节。
显然，8个字节存储label中的各种属性是不够的。
所以当UILabel对象被创建时，电脑会把它放到内存中的某个地方，然后返回一个它的门牌号给你。
比如你的房子是一个实际的对象，而你的门牌号就是关于你的房子这个对象的引用，根据门牌号就可以找到你的房子。
我们来看几组例子：
规则1:当你创建一个常量后，你只能对它赋值一次：
let coord1 = CLLocationCoordinate2D(latitude: 0, longitude: 0)
coord1.latitude = 37.33233141 // 错误
var coord2 = CLLocationCoordinate2D(latitude: 0, longitude: 0)
coord2.latitude = 37.33233141 //正确，因为这是一个变量“var”
但是引用类型常量的值似乎可以改变：
let label = UILabel()
label.text = "Hello, world!" // OK
label.text = "I like change" // OK
这是因为引用类型常量存储的是地址，而不是实际对象的值。但是你不能改变它存储的地址，比如下面的语句是错误的：
let label = UILabel()
let newLabel = UILabel()
label = newLabel //错误
规则2:当你把值类型的对象放到一个新的变量或者常量中去的话，它会产生一份拷贝，比如：
var a = [1, 2, 3]
let b = a
a.append(4)
print(a) // prints [1, 2, 3, 4]
print(b) // prints [1, 2, 3]
而引用类型则不会这样，例如：
var firstLabel = UILabel()
firstLabel.text = "Programmers are the best!"
var secondLabel = firstLabel
secondLabel.text = "I like ice cream"
print(firstLabel.text) // prints “I like ice cream”
为什么secondLabel的文本变更了之后，firstLabel的会跟着一起变呢？因为它们存储的并不是lable对象本身，而是到这个label的引用，见下图：
记住，只有从类中创建的对象是引用类型，其余的都是值类型。
object ownership（对象所有权）
对象不是隐士，不会把自己关到山上不下来（看完全书我都不知道这句话有啥作用）。你的app中到处充斥着对象，它们互相间合作紧密。
你的app中的对象之间的关系可以用对象图表来描述。例如：CurrentLocationViewController和许多对象有关联：
这些是它的实例变量以及实例常量，CurrentLocationViewController拥有它们。同时CurrentLocationViewController也可以被别的对象拥有，它属于UITabBarController，而UITabBarController属于UIWindows。
这只是你app中对象间关系的一小部分。不要把这个概念和类的层级弄混了。
对象所有权是iOS编程中的一个重要课题。你需要清楚地了解哪些对象拥有哪些对象，因为这些对象的存在取决于它（对象所有权） - 你的app的正常运行也取决于它。
如果一个对象不在有任何其他对象拥有它，那么这个对象会被释放掉。另一方面，如果一个对象的拥有者太多，可能会导致它永远无法被释放，最终消耗掉大量的系统内存。
所以“拥有”一个对象到底是什么意思呢？我们这里引入一个概念，strong和weak。
大多数情况下，当你声明一个拥有引用对象的变量时，你就创建了一个strong关系。这个变量就假定拥有这个对象，它和其他同样引用这个对象的变量一起对这个变量负责。
var image: UIImage // a strong variable
在weak关系中，不存在拥有者的概念。一个变量和一个对象之间的关系是weak的话，无法保证这个对象的存活。在声明weak关系时，你需要写明weak关键字：
weak var weakImage: UIImage? // a weak variable
一个对象的生命期取决于它有多少个strong关系的属主，而不是weak类型的。
那么weak类型到底有什么用呢？
它的存在主要是用于避免循环引用，就是两个对象互为属主，它们就永远都不会被释放了。直到内存被耗尽。
在之前的课程中你学习了，将委托方法声明为weak类型的，来避免这种事的发生。过会你会看到另一种类型的循环引用。
另一种常见的使用weak的地方是在声明@IBOutlet属性时。这是因为视图控制器并不是@IBOutlet的真正属主，它的属主其实是视图控制器的顶层视图。
如果你使用strong类型的outlet，不会有任何不良影响，但是假如你使用了weak，那么视图控制器就会明白它仅仅是租用了这些属性，而不是拥有它们。
weak引用有一个副作用，假如你对某个对象是weak引用，那么当这个对象被释放时，你的引用计数器会自动为nil。
这也是一件好事，因为如果不这样做，你会指向一个死去的对象，如果你试图使用它，各种各样的混乱将会发生。 （使用这种“僵尸”对象是没有弱引用的语言程序崩溃的常见原因。）
这也是为什么weak引用变量必须始终是可选项（无论是？还是！），因为它们可能在某个时刻成为nil。
⚠️：Swift有第三种关系类型：无主的。 它和weak很像，用来打破循环。 不同的是，无主变量不会为nil，因此不必是可选型。 它没有weak的功能强大，但是你可能在这里或那里碰到无主型变量。 你需要把它们都当作是weak型就可以了。
总结一下：如果你想保持一段时间的对象，你应该保存一个strong关系。 但是，如果你不需要拥有这个对象，并且不介意它在某个时候离开，那就使用一个weak或者无主的引用。
让我们来看看一个对象有多个所有者的情况。
例如，当用户点击Tag Location按钮时，Current Location视图控制器将CLPlacemark对象传递给Location Details视图控制器。 这两个引用都是strong型的，所以从现在开始，Location Details视图控制器将承担共享所有权。 所以现在CLPlacemark有两个所有者。
共享所有权和对象关系的概念仅适用于引用类型。 值类型总是从一个地方复制到另一个地方，所以他们永远不会拥有多个所有者。
结构也是值类型，比如：
override func prepare(for segue: UIStoryboardSegue, sender: Any?) { ...
controller.coordinate = location!.coordinate
controller.placemark = placemark
}
这行代码把location!.coordinate放入controller.coordinate时会生成一份CLLocationCoordinate2D结构的拷贝。每个视图控制器都会拥有各自独立的一份关于GPS坐标的拷贝。
对于placemark而言，则是每个视图控制器都有一个到CLPlacemark对象的引用。
如果你感到头晕的话，可以停下来，过几天再看一遍。
说真的，如果你理解了这些概念，你就可以很好地编程。 如果不是，不要放弃。 这些可能是非常难以理解。 但是只要继续下去，一定会搞懂。
⚠️：如果你想复制引用类型的对象，则可以将其声明为@NSCopying。 这会创建对象的副本，并将其放入新变量中。 之后这两个变量都指向它们自己的对象。 @NSCopying更像是Objective-C风格的东西，但是你应该了解它一下。