Swift基础语法文章汇总

本文简单介绍Swift对内存的一些特有操作，比如闭包的循环引用，以及逃逸闭包。Swift为了访问的安全，还增加了访问冲突检查。

主要内容：

1. 弱引用
2. 循环引用
3. 逃逸闭包
4. 访问冲突

1. 内存管理

跟OC一样，Swift也是采取基于引用计数的ARC内存管理方案（针对堆空间），Swift的ARC中有3种引用。

Swift的引用种类.png

2. 弱引用

/*
 1、弱引用
 */
protocol Livable : AnyObject {}
class Person {}

weak var p0: Person?
weak var p1: AnyObject?
weak var p2: Livable?

unowned var p10: Person?
unowned var p11: AnyObject?
unowned var p12: Livable?

说明：

• weak、unowned只能用在类实例上面
• 因为weak可以设置为nil，所以必须用可选项
• 会发生改变，所以需要用var

3. 循环引用

循环引用就是两个对象相互持有，无法释放会导致内存泄漏，和OC一样，所以重点看一下闭包的循环引用，其实也就和block一样

循环引用的解决：weak、unowned 都能解决循环引用的问题，unowned 要比 weak 少一些性能消耗，在生命周期中可能会变为 nil 的使用 weak，初始化赋值后再也不会变为 nil 的使用unowned

3.1 方法闭包的循环引用

p调用fn，fn的闭包内引用了p，所以就造成了循环引用
循环引用：

/*
 2、闭包的循环引用
 */
class Person {
    var fn: (() -> ())?
    func run() { print("run") }
    deinit { print("deinit") }
}
func test() {
    let p = Person()
    p.fn = { p.run() }
}
test()

解决：

class Person {
    var fn: (() -> ())?
    func run() { print("run") }
    deinit { print("deinit") }
}
func test() {
    let p = Person()
    p.fn = {
        [weak p] in
        p?.run()
    }
}
test()

说明：
1、注意设置弱引用格式
2、弱引用就有可能是nil，所以必须是可选项，而可选项就需要使用？来自动解包，此处不要用!方式，否则nil仍然调用run()崩溃
3、注意这种格式，这个是闭包的写法，所以有in，[weak p]是捕获列表，而不是参数列表。如果需要传入参数后面还要加(age)

3.2 属性闭包的循环引用

循环引用：

class Person {
    lazy var fn: (() -> ()) = {
        [weak self] in
        self?.run()
    }
    func run() { print("run") }
    deinit { print("deinit") }
}
func test() {
    let p = Person()
    p.fn()
}
test()

说明：
1、lazy的时候，会在调用fn属性时才会调会初始化fn
2、在这个闭包表达式中，这里的self.run()中self是必须要写的，编译器想让开发者可以更清楚的知道这里使用了self，以此知道这里强引用了self
3、为了解决强引用，使用weak进行弱引用设置一下

不产生循环引用：

class Person {
    var age: Int = 0
    lazy var getAge: Int = {
        self.age
    }()
    deinit { print("deinit") }
}

说明：

4. 逃逸闭包

非逃逸闭包、逃逸闭包，一般都是当做参数传递给函数

4.1 非逃逸闭包

闭包调用发生在函数结束前，闭包调用在函数作用域内

/*
 3、逃逸闭包
 */
 //非逃逸闭包
import Dispatch
typealias Fn = () -> ()
// fn是非逃逸闭包
func test1(_ fn: Fn) { fn() }

4.2 逃逸闭包

代码：

class Person {
    var fn: Fn
    // fn是逃逸闭包
    init(fn: @escaping Fn) {
        self.fn = fn
    }
    func run() {
        // DispatchQueue.global().async也是一个逃逸闭包
        // 它用到了实例成员（属性、方法），编译器会强制要求明确写出self
        DispatchQueue.global().async {
            self.fn()
        }
    }
}

说明：

• 很明显都是逃逸闭包，因为不在函数内执行完成
• 这个async本身就是一个闭包，所以也必须使用self来调用
• 闭包有可能在函数结束后调用，闭包调用逃离了函数的作用域，需要通过@escaping声明

逃逸闭包不可以捕获inout参数

逃逸闭包使用注意点.png

说明：
1、非逃逸闭包可以捕获inout参数
2、other2虽然本身是非逃逸闭包，但是可以强制设置成逃逸闭包
3、逃逸闭包不能捕获inout参数，会报错
4、因为逃逸闭包的调用时机无法确定，无法修改捕获的外界的值。

5. 访问冲突

Swift对于可能会发生读取冲突的编码错误会进行编译报错

内存访问冲突会在两个访问满足下列条件时发生
条件：

1. 至少一个是写入操作
2. 它们访问的是同一块内存
3. 它们的访问时间重叠（比如在同一个函数体内）

内存访问冲突：

/*
 4、内存访问冲突
 */
// 存在内存访问冲突
// Simultaneous accesses to 0x0, but modification requires exclusive access
var step = 1
func increment(_ num: inout Int) { num += step }
increment(&step)

说明：
1、传入的是step，因此num也是step，他们二者访问的是同一份内存
2、step += step 说明step在读取，也在写入
3、在同一个函数内进行的同一个操作语句，因此访问时间重叠

解决冲突：

// 解决内存访问冲突
var copyOfStep = step
increment(&copyOfStep)
step = copyOfStep

说明：

• 不能同时操作同一份内存
• 其实只要设法三个条件不能同时满足就可以解决冲突

基本数据类型的冲突

访问冲突示例1.png

说明：

• 第二次调用传入的是num1，所以在y = sum - x时会操作同一份内存

组合类型的冲突

访问冲突示例2.png

说明：
1、如果操作同一个类型的不同成员，也会报错，整体认为是同一份内存
2、因此这里的同一份内存可以理解为查找该数据时使用的地址（通过首地址的地址偏移来查找的）

重叠访问属性安全的条件：
1、你只访问实例存储属性，不是计算属性或者类属性
2、结构体是局部变量而非全局变量
3、结构体要么没有被闭包捕获要么只被非逃逸闭包捕获

案例：

func balance(_ x: inout Int, _ y: inout Int) {
    let sum = x + y
    x = sum / 2
    y = sum - x
}
struct Player {
    var name: String
    var health: Int
    var energy: Int
    mutating func shareHealth(with teammate: inout Player) {
        balance(&teammate.health, &health)
    }
}
func test() {
    var tulpe = (health: 10, energy: 20)
    balance(&tulpe.health, &tulpe.energy)
    
    var holly = Player(name: "Holly", health: 10, energy: 10)
    balance(&holly.health, &holly.energy)
}
test()

说明：

• 放在函数中，而且访问的是实例存储属性就不会发生冲突
• 满足以上两个条件，那么访问的实例存储属性就是在栈中，栈的特点来说是不会冲突的（生命周期短，作用域只在栈中）