在开始逃逸闭包与非逃逸闭包之前，先普及一个知识点，即如果编译成SIL文件：
编译成SIL文件：
swift使用的编译器为swiftc，OC使用的为clang
swiftc命令查询：swiftc -h
//将swift文件生成sil文件
swiftc -emit-sil main.swift >> main.sil && open main.sil
//带转译
swiftc -emit-sil main.swift | xcrun swift-demangle >> main.sil && open main.sil
//IR
swiftc -emit-ir main.swift | xcrun swift-demangle >> main.ll && open main.ll
//UIKit
swiftc -emit-sil -target x86_64-apple-ios13.5-simulator -sdk $(xcrun --show-sdk-path --sdk iphonesimulator) ViewController.swift > ViewController.sil
接下来主要分析逃逸闭包&非逃逸闭包
当闭包作为一个实际参数传递给一个函数时，并且是在函数返回之后调用，那么这就是一个逃逸闭包；
一般使用@escaping来明确闭包是允许逃逸的。
注意：
1、如果用@escaping修饰闭包后，就必须显示的在闭包中使用self
2、swift3.0之后，系统默认闭包参数就是被@nonescaping修改
//定义一个函数，闭包作为其函数(默认不带任何参数)
func testclosure1(_ closure: ()->()){
}
使用SIL命令，生成SIL文件(如下图)，来分析默认情况下，系统默认是什么类型的闭包
通过上图可知，系统默认闭包是非逃逸闭包，
执行时机：在函数体内执行
非逃逸闭包的生命周期：函数执行完之后，闭包也就消失了
逃逸闭包的两种调用情况
一、延迟调用
二、作为属性存储，在后面进行调用
分别针对两种情况进行代码演示及说明
一、延迟调用
在延迟方法中调用逃逸闭包
var escapingClosure: ((Int)->Void)?//定义一个闭包属性
func testDelayExecute(closure:@escaping(Int)->Void){
var total =10
total += 1
self.escapingClosure= closure
//延迟执行
DispatchQueue.global().asyncAfter(deadline: .now()+1) {
print("***escaping closure execute***")
closure(total)
}
print("func execute down")
}
func run(){
self.testDelayExecute { i in
print(i)
}
}
调用：
var e = EscapingClosures()
e.run()
执行结果（输出）：
func execute down
***deinit***
***escaping closure execute***
11
当前方法执行的过程中不会等待闭包执行完成后再执行，而是直接返回，所以当前闭包的生命周期要比方法长
二、作为属性存储，在后面进行调用
代码可以参考上面的代码：
escapingClosure作为类的属性，在方法testDelayExecute执行完毕之后才执行，这时闭包的生命周期比当前函数的生命周期长
当闭包作为存储属性时，主要有以下几点说明：
1、定义一个闭包属性
2、在方法中对闭包属性进行赋值
3、在合适的时机调用(与业务逻辑相关)
闭包的生命周期比当前方法的生命周期长
逃逸闭包与非逃逸闭包的区别
一：非逃逸闭包
一个接受闭包作为参数的函数，闭包是在这个函数结束前被调用，即可以理解为闭包是在函数作用域结束前被调用
1、不会产生循环引用，因为闭包的作用域在函数作用域内，在函数执行完成后，就会释放闭包捕获的所有对象
2、针对非逃逸闭包，编译器会优化：省略内存管理调用
3、非逃逸闭包捕获的上下文保存在栈上，而不是堆上
二：逃逸闭包
一个接受闭包作为参数的函数，逃逸闭包可能会在函数返回之后才被调用，即：闭包逃离了函数的作用域
1、可能产生循环引用，因为逃逸闭包中需要显示的引用self。而self可能持有闭包变量（与OC中block类似）
2、一般用于异步函数的返回，例如网络请求
使用建议：如果没有特别需要，开发中使用非逃逸闭包有利于内存优化的，所以apple把闭包区分为两种，特殊情况时再使用逃逸闭包
为什么要区分 @escaping与@nonescaping？
1、为了内存管理，闭包会强引用它捕获的所有对象，这样闭包会持有当前对象，容易导致循环引用
2、非逃逸闭包不会出现循环引用，她会在函数作用域内使用，编译器可以保证在函数结束时闭包会释放它捕获的所有对象
3、使用非逃逸闭包可以使编译器应用更多强有力的性能优化，例如：当明确了一个闭包的生命周期的话，就可以省去一些保留retain和释放release的调用
4、非逃逸闭包它的上下文可以保存在栈上而不是堆上
还有一种闭包自动闭包，使用场景也非常的多
比如下面这段代码：
func baseCaseExecute(_ condition:Bool,_ message:String){
if condition {
print("***\(message)***")
}
}
func productCase() -> String{
print("***productCase 产生条件结果***")
return "logic product case"
}
let e = EscapingClosures()
e.baseCaseExecute(true, e.productCase())
e.baseCaseExecute(false, e.productCase())
当像上面这样调用的时候，输出如下：
***productCase 产生条件结果***
***logic product case***
***productCase 产生条件结果***
会发现无论condition是否为trun，produceCase中的方法都会执行；假想如果productCase方法是一个超级耗时的方法，那么这样做将会得不偿失，接下来将使用闭包的方式针对方法进行优化：
func baseCaseExecute2(_ condition:Bool,_ message:()->String){
if condition {
print("***\(message())***")
}
}
e.baseCaseExecute2(true, e.productCase)
e.baseCaseExecute2(false, e.productCase)
通过以上调用，执行结果如下：
***productCase 产生条件结果***
***logic product case***
发现没，如果条件为false的话，productCase方法是不执行的；所以通过闭包参数的传递可以避免一些资源的浪费，特别是是涉及到耗时逻辑的情况下
因为message为String类型，那么此时如果给函数传递一个String类型的参数，会是什么情况呢？会发现编译不过的，接下来自动闭包就出现啦，将方法进行如下修改：
func baseCaseExecute3(_ condition:Bool,_ message:@autoclosure()->String){
if condition {
print("***\(message())***")
}
}
可以通过@autoclosure将当前闭包声明成一个自动闭包，不接收任何参数，返回值是当前内部表达式的值
所以当传入一个String时，其实就是将String放入一个闭包表达式中，在调用的时候返回
e.baseCaseExecute3(true,"execute")
e.baseCaseExecute3(false,"not execute")
返回结果如下：
***execute***
自动闭包就相当于{}包裹传入的对象，然后返回{}内的值
{
//表达式里的值
return "this is auto closure return content"
}
