Swift3.0 - 真的很简单
Swift3.0 - 数据类型
Swift3.0 - Array
Swift3.0 - 字典
Swift3.0 - 可选值
Swift3.0 - 集合
Swift3.0 - 流控制
Swift3.0 - 对象和类
Swift3.0 - 属性
Swift3.0 - 函数和闭包
Swift3.0 - 初始化和释放
Swift3.0 - 协议protocol
Swift3.0 - 类和结构体的区别
Swift3.0 - 枚举
Swift3.0 - 扩展
Swift3.0 - 下标
Swift3.0 - 泛型
Swift3.0 - 异常错误
Swift3.0 - 断言
Swift3.0 - 自动引用计数(strong,weak,unowned)
Swift3.0 - 检测API
Swift3.0 - 对象的标识
Swift3.0 - 注释
Swift3.0 - 元类型
Swift3.0 - 空间命名
Swift3.0 - 对象判等
Swift3.0 - 探究Self的用途
Swift3.0 - 类簇
Swift3.0 - 动态调用对象(实例)方法
Swift3.0 - 文本输出
Swift3.0 - 黑魔法swizzle
Swift3.0 - 镜像
Swift3.0 - 遇到的坑
- 自动引用计数的工作原理
1.每次创建一个类的新实例时，都会分配一个内存块来存储有关该实例的信息。此内存保存实例的类型的信息，以及与该实例关联的任何存储属性的值
2.当一个实例不再需要时，ARC释放由该实例使用的内存，以便内存可以用于其他用途
3.ARC 释放对象后,它将不能再继续访问对象的属性,或者调用对象方法,如果你依然继续访问对象,App将会崩溃
4.为了确保对象使用时, 不被释放,ARC 跟踪属性,变量和常量,只要有一个对象引用存在,在对象不会被释放
5.当您将一个类实例分配给属性、常量或变量时，属性、常量或变量对实例会有一个强引用,确保对象不会被释放
- 探讨strong,weak和unowned 的区别
我们先创建一个对象
class Person{
var name:String
init(name:String) {
self.name = name
}
deinit {
print("对象释放了,name的值为:\(name)")
}
}
创建一个Person实例对象,然后对其进行强引用
var reference1:Person? = Person(name: "酷走天涯")
运行结果:
没有释放对象,因为它将对象强引用
我们不再引用对象
reference1 = nil
运行结果:
对象释放了,name的值为:酷走天涯
Program ended with exit code: 0
我们使用weak引用对象
weak var reference1:Person? = Person(name: "酷走天涯")
运行结果:
对象释放了,name的值为:酷走天涯
Program ended with exit code: 0
我们修改代码为
weak var reference1:Person = Person(name: "酷走天涯")
系统报错:
weak 修饰的变量或者常量必须为可选值 ? 或者 ！
使用unowned 引用对象
unowned var reference1:Person? = Person(name: "酷走天涯")
unowned var reference1:Person! = Person(name: "酷走天涯")
报错:
不能修饰可选值类型的变量或者常量
修改代码为
unowned var reference1:Person = Person(name: "酷走天涯")
运行结果:
对象释放了,name的值为:酷走天涯
Program ended with exit code: 0
阶段总结:
1.强引用的对象,不会被释放
2.weak 或者unowned 引用的对象,当没有强引用的时候,会被立即释放
3.weak 修饰的变量和常量必须为可选类型,但是unowned刚好和其相反必须为非可选类型
为了验证第三条结论,我们做下面的练习
var reference1:Person = Person(name: "酷走天涯")
weak var reference2 = reference1
unowned var reference3 = reference1
print(reference2)
print(reference3)
运行结果:
Optional(swift3_0.Person)
swift3_0.Person
Program ended with exit code: 0
如果代码为
var reference1:Person = Person(name: "酷走天涯")
weak var reference2 = reference1
unowned var reference3 = reference2
系统报错,原因分析
weak 修饰的变量reference2 虽然没有指明变量类型,但是swift会推断出来它的类型为Person?,这个时候我们把一个person? 的类型付给unowned修饰的变量,系统不运行
修改代码为下面,系统编译通过
var reference1:Person = Person(name: "酷走天涯")
weak var reference2 = reference1
unowned var reference3 = reference2!
- 为什么要使用weak 和unowned
定义两个类Student 和School,Student 有一个属性school ,school 也有一个属性student,我们让其相互引用
// 学生类
class Student{
var school:School?
deinit {
print("学生对象释放")
}
}
// 学校类
class School{
var student:Student? // 强引用
deinit {
print("学校对象释放了")
}
}
var school:School? = School()
var student:Student? = Student()
school!.student = student
student!.school = school
我们让school 和 student 为nil
school = nil
student = nil
运行代码
发现两个对象都没有释放
原因分析:
school 要释放必须先释放它的属性Student ,系统就去释放Student的内存空间,发现他有一个属性叫school 然后又去释放school,就这样构成死循环,谁都无法释放
遇到上面的问题,原因就是相互强引用了,接下来,我们使用将student的属性school 使用weak修饰
// 学生类
class Student{
weak var school:School?
deinit {
print("学生对象释放")
}
}
运行下边的代码
school = nil
student = nil
运行结果:
学校对象释放了
学生对象释放
运行原理分析:
首先我们释放的school,没有被弱引用,引用计数器减一,
你怎么选择unowned和weak
先看下面的例子
使用unowned
// 学生类
class Student{
unowned var school:School
init(school:School) {
self.school = school
}
deinit {
print("学生对象释放")
}
func describe() {
print("学生在\(school.describe())上学")
}
}
// 学校类
class School{
var student:Student? // 强引用
deinit {
print("学校对象释放了")
}
func describe() ->String {
return "学校"
}
}
var school:School? = School()
var student:Student? = Student(school:school!)
school!.student = student
// 学校不用了,把学校释放掉
school = nil
student?.describe()
运行:
崩溃
原因:
释放掉school对象,然后在student的方法中调用了school的方法,方法已经不存在了,所以崩溃了
使用weak
// 学生类
class Student{
weak var school:School?
deinit {
print("学生对象释放")
}
func describe() {
if let school = self.school{
print("学生在\(school.describe())上学")
}
}
}
// 学校类
class School{
var student:Student? // 强引用
deinit {
print("学校对象释放了")
}
func describe() ->String {
return "学校"
}
}
var school:School? = School()
var student:Student? = Student()
school!.student = student
student!.school = school
运行下面的代码
// 学校不用了,把学校释放掉
school = nil
student?.describe()
结果:
学校对象释放了
分析:
由于school被弱引用,计数器减一,school对象就被释放了,所以我们在调用的时候进行检测,如果对象存在再去执行方法,这样就避免了此类错误
总结:
使用unowned 修饰属性时,必须保证自己的实体独享要比引用的对象先释放
如果循环引用中,弱引用的对象必须为非可选类型,这个时候,就可以考虑使用unowned
- 实例分析
a.
class HTMLElement {
let name: String
let text: String?
lazy var asHTML: () -> String = {
if let text = self.text {
return "<\(self.name)>\(text)</\(self.name)>"
} else {
return "<\(self.name) />"
}
}
init(name: String, text: String? = nil) {
self.name = name
self.text = text
}
deinit {
print("\(name) is being deinitialized")
}
}
var x:HTMLElement? = HTMLElement(name: "title")
x = nil
运行结果:
title is being deinitialized
Program ended with exit code: 0
分析:
眨眼一看,释放了,为什么被释放了,因为我们使用lazy关键字,asHTML 闭包没有被创建,这里注意,如果要在存储属性的闭包中访问自己的属性,必须加Lazy
那我们让闭包代码执行以下
var x:HTMLElement? = HTMLElement(name: "title")
x?.asHTML()
x = nil
再次运行:
惊奇的发现,对象释放不了
分析原因:
释放对象,首先释放属性,释放name发现name被闭包引用了,然后去释放闭包,发现释放self.name ,构成了死循环
修改部分代码如下
lazy var asHTML: () -> String = {
[unowned self] in
if let text = self.text {
return "<\(self.name)>\(text)</\(self.name)>"
} else {
return "<\(self.name) />"
}
}
运行结果:
title is being deinitialized
Program ended with exit code: 0
分析:
释放name的时候, 是被弱引用的,引用计数没有加1,不用考虑,直接释放自己，释放asHTML 时发现,name 已经被释放了,
