Swift3.0 - 自动引用计数(strong,weak,unowned)

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 已经被释放了,

推荐阅读更多精彩内容