首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >Swift3.0 - 自动引用计数(strong,weak,unowned)

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

作者头像
酷走天涯
发布2018-09-14 14:48:51
5710
发布2018-09-14 14:48:51
举报
  • 自动引用计数的工作原理

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

本文参与 腾讯云自媒体分享计划,分享自作者个人站点/博客。
原始发表:2016.10.07 ,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档