内存管理
ARC是Swift默认的内存管理机制,其针对堆上的对象,由编译器自动生成操作引用计数的指令(retain或者release)来管理对象的引用计数增加或减少.程序员是无法手工控制
那些类的对象受ARC管理
--类 class
--闭包 closure
那些对象不受ARC管理
--基础数值类型
--结构 struct
--枚举 enum
--元组 tuple
关于Aute Release
Swift原生对象不支持 autorelease消息,也就没有必要使用Autorelease Pool 来管理内存峰值
如果Swift调用Objective-C函数返回autorelease对象,那么如果出现内存峰值过高的风险,仍然需要支持使用Autorelease Pool 来管理
Autorelease Pool 在Swift中使用尾随闭包形式实现
func useObjcAutoReleaseObject() {
if let filepath = NSBundle.mainBundle().pathForResource("2016", ofType: "jpg"){
//autoreleasepool({ //如果放着这里就是每5000次释放
for _ in 0..<5 {
//autoreleasepool Pool跟随 闭包形式
autoreleasepool({//autoreleasepool放在这里是以1000次释放
for _ in 0..<1000{
let data = NSData.dataWithContentsOfMappedFile(filepath)
}
})
}
}
}
循环引用与内存泄露
对象间的循环引用会造成ARC引用计数无法释放被引用的任何一个个对象,从而造成内存泄露
解决循环引用的造成的内存泄露有3种方式:
1在合适的地方手动将循环引用解除.
2如果允许对象引用为nil,可将引用声明为弱引用(weak)
3如果不允许对象引用为nil,可将对象声明为无主引用(unowned)
弱引用在对象释放后,ARC会将引用设置为nil,无主引用会在对象后,ARC不会设置nil,访问时会抛运行水错误(空悬指针)
解决循环引用的造成的内存泄露2种解决案例:
class Computer{
var name : String
var display:Monitor?
init(name:String){
self.name = name
print("COmputer init")
}
deinit{
print("Computer deinit")
}
}
class Monitor {
var no:Int
//解决方案2.添加weak 在ARC 里面就是不算引用计数
// weak var device:Computer?
var device:Computer?
init(no:Int){
self.no = no
print("Monitor init")
}
deinit{
print("Monitor deinit")
}
}
var imac:Computer?
var screen:Monitor?
imac = Computer(name: "Jason's")
screen = Monitor(no: 20)
imac!.display = screen
screen!.device=imac
//解决方案1.适当位置手工把循环引用解除
//imac!.display = nil
imac = nil
screen = nil
解决循环引用的造成的内存泄露无主引用案例:
class Car {
var name:String
var engine:Engine?
init(name:String){
self.name = name
print("Car init")
}
deinit{
print("Car deinit")
}
}
class Engine {
var no:Int
//这对象允许Car 为nil 所以unowned 打破循环引用
//unowned var car:Car
var car:Car
init(no:Int,car:Car){
self.no = no
self.car = car
print("Engine init")
}
deinit{
print("Engine deinit")
}
}
var bmw:Car?
var engine:Engine?
bmw=Car(name:"BMW")
engine=Engine(no: 400, car: bmw!)
bmw!.engine=engine
bmw=nil
未使用注释时候
两个对象没有释放
使用unowned后,两个对象
闭包的内存管理
其实跟之前相差不大 ,但是还有一定的要求
如果闭包满足一下两个条件,就会产生循环引用,造成内存泄露
1.将闭包对象设置为self的属性,产生"从self->闭包对象的引用"
2.闭包内使用实例成员,会捕获self,产生"从闭包对象->self 的引用"
class Employee{
var name: String
var printer:(()->())?
/*
lazy var printer:()->() = {
preint("name:\(self.name)")
}*/
init(name:String){
self.name = name
//下面是一个闭包哦
//将闭包对象设置为self的属性,产生"从self->闭包对象的引用"
self.printer = {
//闭包内使用实例成员,会捕获self,产生"从闭包对象->self 的引用"
//方法2:使用弱引用[weak slef] in 只能引用于闭包
// [weak self] in
// print("name:\(self!.name)")
//方法3:使用无主引用[unwoned slef] in 只能引用于闭包
// [unwoned self] in\
// print("name:\(self.name)")
//weak和unwoned 的选用是主要围绕你的对象能否nil
print("name:\(self.name)")
}
print("Empolyee init")
}
deinit{
print("Empolyee deinit")
}
}
var employee:Employee?
employee = Employee(name: "Jason")
employee?.printer?()
//方法1,手工处理
//employee?.printer=nil
//析构器没有调用
employee = nil
Weak-Strong Dance
对象在弱引用或者无主引用期间,随时"有可能被释放掉",从而导致弱引用为nil,或者抛运行时错误
class Employee {
var name:String
init(name:String){
self.name = name
print("Empliyee init")
}
func doClosure() {
dispatch_async(dispatch_get_global_queue(0, 0)){
[weak self] in
// //方案一
self?.process("first process")
usleep(500)
//这个过程中,对象已经被释放
self?.process("second process")
//
// //方案2 临时转化为强引用,
// if let strongSelf = self {
// strongSelf.process("first process")
// usleep(500)
// strongSelf.process("second process")
// ///方案一不同当这个强引用玩了之后, 才能释放
// }
// //方案3 使用withExtendedLifetime
// withExtendedLifetime(self){
// self?.process("first process")
// usleep(500)
// self?.process("second process")
// ///方案一,方案2不同的是withExtendedLifetime延长对象声明周期
// }
}
}
deinit{
print("Employee Deinit")
}
func process(message:String) {
print(message)
}
}
var employee:Employee? = Employee(name: "jason")
employee?.doClosure()
dispatch_async(dispatch_get_global_queue(0, 0)){
usleep(100)
employee = nil
}
dispatch_main()
使用方案一,second process没有打印出来
使用方案2方案3,second process能打印出来