首页 » Swift » Swift(十六、自动引用计数)

Swift(十六、自动引用计数)

2015-11-10 19:40:06阅读(375)


1、Swift入门学习笔记(第一版),对Swift的基础知识点进行梳理总结。知识点一直在变,只是作为参考,以苹果官方文档为准~

2、在学习完基本的知识点以后会结合官方文档及相关资料,在此版本的基础上进行添加更改。


十六、自动引用计数

引用计数仅适用于类实例。结构体和枚举类型是值类型,不是引用类型,不是通过引用方式存储和传递


1、自动引用计数的工作机制

与OC大同小异,此处不累述

class Person {
    init() {
        print("Init")
    }

    deinit {
        print("Deinit")
    }
}

var reference1:Person?
var reference2:Person?
var reference3:Person?
//定义为可选类型是为了可赋nil

reference1 = Person()       //输出Init
reference2 = reference1     //无输出
reference3 = reference1     //无输出

//赋值nil,断开强引用
reference1 = nil            //无输出
reference2 = nil            //无输出
reference3 = nil            //输出Deinit

2、循环引用解决方案

与OC大同小异,此处不累述

Swift提供两种解决循环引用的问题:弱引用(weak reference)和无主引用(unowned reference)
在生命周期内会变为nil的实例使用弱引用。对初始化赋值后不会被赋值为nil的实例使用无主引用


3、弱引用

a、weak关键字表示弱引用,一方强一方弱

b、必须声明为变量,表示其值在运行时可修改

c、必须声明为可选类型,因为弱引用可为nil

class Person {
    var pet:Dog?
    deinit {
        print("Person deinit")
    }
}

class Dog {
    weak var owner:Person?
    deinit {
        print("Dog deinit")
    }
}
//可选类型,一个人可以有狗也可以没狗,一只狗可以有主人也可以是流浪狗

//建立引用关系
var person:Person? = Person()
var pet:Dog?       = Dog()
person!.pet        = pet
pet!.owner         = person

person = nil        //person的引用计数为0,person被释放,pet引用计数变为2
pet    = nil        //pet引用计数变为0

Output:

Person deinit
Dog deinit

注意:在使用垃圾收集的系统里,弱指针有时用来实现简单的缓存机制,因为没有强引用的对象只会在内存压力触发垃圾回收时才被销毁,但在ARC中一旦不被强引用,就会被立刻销毁,因此不适合用来实现缓存


3、无主引用

a、unowned表示无主引用

b、无主引用永远有值

c、总是被定义为非可选类型

class Person {
    var pet:Dog?
    deinit {
        print("Person deinit")
    }
}

class Dog {
    unowned let owner:Person
    init(owner:Person) {
        self.owner = owner
    }
    deinit {
        print("Dog deinit")
    }
}
//可选类型,一个人可以有狗也可以没狗,但是狗必须要有主人

var person:Person?
person = Person()
person!.pet = Dog(owner: person!)
//person引用计数为1,dog引用计数也为1只有person引用它

person = nil
//person为nil,那么没有指向Person实例的强引用,实例被销毁。之后,指向Dog实例的强引用也没了,该实例随之被销毁

Output:

Person deinit
Dog deinit

4、无主引用及隐式解析可选属性

前面阐述了两个实例均可以为nil的情况使用弱引用,以及其中一方为nil使用无主引用。
接下来阐述两方都必须有值,均不能为nil的情况

解决方法:一个类使用无主属性,另一个类使用隐式解析可选属性
实际上操作跟上面的一样,就是改成,表示不能为nil即可

class Person {
    var pet:Dog!
    init(petName:String) {
        self.pet = Dog(name: petName, owner: self)
        print("Person init")
    }
    deinit {
        print("Person deinit")
    }
}

class Dog {
    let name:String
    unowned let owner:Person
    init(name:String,owner:Person) {
        self.name = name
        self.owner = owner
        print("Dog init")
    }
    deinit {
        print("Dog deinit")
    }
}

var person = Person(petName: "Lucky")
//person.pet可以被访问,不用!展开
print(person.pet.name)

Output:

Dog init
Person init
Lucky

5、闭包引起的循环引用

如果闭包定义在类内部,而类又引用了实例的属性或者方法(捕获),产生循环引用

解决方案:闭包捕获列表

class Person {
    var name:String
    lazy var printName:Void -> Void = {
       print(self.name)
    }
    init(name:String) {
        self.name = name
    }
    deinit {
        print("Deinit")
    }
}
//lazy延迟加载,只有当类实例构造完成之后才得到,不加无法使用self
var p:Person? = Person(name: "Zane")
p = nil

Output:

Deinit

由打印结果可知,p实例销毁了,因为闭包只有在使用的时候才会初始化,因此这里没有循环引用

接下来使用闭包

var p1:Person? = Person(name: "Zane")
p1!.printName()
p1 = nil

Output:

Zane

打印结果并没有Deinit,循环引用,实例未释放


解决方法:定义捕获列表,声明每个捕获的引用为弱引用或者无主引用

a、包含参数列表和返回类型,把捕获列表放前面,以及一些初始化的变量例如delegate等,逗号隔开

lazy var test:(Int,String) -> String = {
    [unowned self,weak delegate = self.delegate!](index:Int,string:String)->String in
    //闭包操作
}

b、无指明参数类型或者返回值,即使有也可以不写,编译器自己推断

lazy var printName:Void -> Void = {
    [unowned self] in print(self.name)
}

这里修饰符weak还是unowned前文已讲

版权声明:本文为博主原创文章,转载请注明出处http://blog.csdn.net/zsk_zane

最新发布

CentOS专题

关于本站

5ibc.net旗下博客站精品博文小部分原创、大部分从互联网收集整理。尊重作者版权、传播精品博文,让更多编程爱好者知晓!

小提示

按 Ctrl+D 键,
把本文加入收藏夹