闭包尽量选择非逃逸闭包
函数是引用类型
? func addTwoInts(_ a: Double, _ b: Double) -> Double {
?? ? ? return a + b
?? }
var a = addTwoInts
var?b = a
函数的内存结构
1. 函数类型?type(of: a)
2.unsafeBitCast 指针转换
struct TargetFunctionTypeMetadata{
? ? var kind: Int
? ? var flags: Int
? ? func numberArguments() -> Int{
? ? ? ? return self.flags & 0x0000FFFF
? ? }
}
let type = type(of: a)
let functionType = unsafeBitCast(type as Any.Type, to: UnsafeMutablePointer<TargetFunctionTypeMetadata>.self)?print(functionType.pointee.numberArguments()) // 2
闭包
闭包的本质
{ i8*, %swift.refcounted* }
闭包的执行地址? + 捕获变量堆空间的地址
1.?Box<T> 代表一个实例对象
2.?HeapObject实例对象的metadata 和引用计数
3.Box<T> 中的value?捕获的值
struct ClosureData{
? ? var ptr: UnsafeRawPointer //?闭包的执行地址
? ? var capatureValue: UnsafePointer<Box<T>> //??捕获变量堆空间的地址
}
struct HeapObject{? ?
????var metadata: UnsafeRawPointer? ?
????var refcount1: Int32? ?
????var refcount2: Int32
}
struct Box<T>{? ?
????var object: HeapObject? ?
????var value: T
}
1.?NoMeanStruct的内存地址和结构体第一个属性的内存地址是一样的，所以结构体NoMeanStruct的地址就是闭包的地址
struct NoMeanStruct{
?? var f: () -> Int
}
? ??var a = 10
? ? ? var f = NoMeanStruct {
?? ? ? ? a+= 30
?? ? ? ? return a
? ? ? }
? ? ? var ptr = UnsafeMutablePointer<NoMeanStruct>.allocate(capacity: 1)
? ? ? ptr.initialize(to: f)
//? ? ? ptr[0] = f
? ? ? defer {
?? ? ? ? ptr.deinitialize(count: 1)
?? ? ? ? ptr.deallocate()
? ? ? }
? ? ? var ctx = ptr.withMemoryRebound(to: ClosureData<Box<Int>>.self, capacity: 1) {
?? ? ? ? return $0.pointee
? ? ? }
print(ctx)
1. 第一个打印出结果，?闭包的本质是闭包的执行地址? + 捕获变量堆空间的地址
2.第二个 lldb,看出ptr 是闭包的执行地址
3.第三个lldb，看出object是个堆地址
.ll 文件简单语法
<type> *指针类型
[<elementnumber> x <elementtype>?] 数组
{..., ...} 结构体
局部变量??var?runningTotal =?10?
func makeIncrementer() -> () -> Int {
? ? var runningTotal = 10 ?//局部变量
? ? func incrementer() -> Int {
? ? ? ? runningTotal+= 1
? ? ? ? return runningTotal
? ? }
? ? return incrementer
}
let incr = makeIncrementer()
解析成.ll 文件
define i32 @main(i32 %0, i8** %1) #0 {
entry:
...
? %3 = call swiftcc { i8*, %swift.refcounted* } @"$s4main15makeIncrementerSiycyF"()
? ...
}
makeIncrementer() 返回??{ i8*, %swift.refcounted* } ?一个结构体，里面2个指针
%swift.refcounted = type { %swift.type*, i64 }
%swift.type = type { i64 }
推断出闭包是一个{?i8*,??type { type { i64 }, i64 }}
逃逸闭包
延长闭包的生命周期
逃逸闭包在函数内部异步执行或者被属性存储
非逃逸闭包
不会产生循环引用，函数作用域内释放??
编译器更多性能优化 （retain， relsase）?
上下文的内存保存再栈上，不是堆上?
