Swift中的捕获列表:强引用,弱引用,无主引用之间的区别

捕获列表位于代码中的闭包参数列表之前,并将环境中的值捕获为强,弱或无主。我们经常使用它们,主要是为了避免循环引用

首先,看一下这个问题:

class Singer {
    func playSong() {
        print("Shake is off!")
    }
}

创建一个方法,方法中实例化Singer,并使用Singer实例的playSong()创建一个闭包,并返回这个闭包以供其他地方使用

func sing() -> () -> Void {
    let taylor = Singer()
    
    let singing = {
        taylor.playSong()
        return
    }
    return singing
}

最后,我们可以调用sing()来获取我们可以在任何想要打印playSong()的地方调用的函数

let singFunction = sing()
singFunction()      //打印出 Shake is off!

强引用

除非你要求特别的东西,否则Swift会使用强大的捕获功能。这意味着闭包将捕获闭包内使用的任何外部值,并确保它们永远不会被破坏

func sing() -> () -> Void {
    let taylor = Singer()
    
    let singing = {
        taylor.playSong()
        return
    }
    return singing
}

那个taylor常量是在sing()函数内部进行的,所以通常它会在函数结束时被销毁。但是,它会在闭包内部使用,这意味着只要闭包存在某个地方,即使函数返回后,Swift也会自动确保它保持活动状态。

这是一个强大的捕获行动。如果Swift允许taylor被摧毁,那么关闭将不再是安全的 - 它的taylor.playSong()方法将不再有效

弱引用

Swift让我们指定一个捕获列表来确定如何捕获闭包内使用的值。与强引用常见使用的是弱引用,它改变了两件事:

1.闭包不能保持弱捕获的值,因此它们可能会被破坏并设置为nil

2.作为1的结果,弱引用值在Swift中始终是可选的。这会阻止你假设它们存在,而实际上它们可能不存在。

func sing() -> () -> Void {
    let taylor = Singer()

    let singing = { [weak taylor] in
        taylor?.playSong()
        return
    }

    return singing
}

[weak taylor]是我们的捕获列表.它是闭包的一个特定部分,我们就如何捕获值给出具体指示,在这里我们说taylor应该被弱引用,这就是为什么我们需要使用taylor?.playSong() - 它现在是可选的,因为它可以在任何时候设置为nil

方法修改以后,调用singFunction()会发现不会打印任何东西,原因是taylor只存在于sing()中,因为它返回的闭包并没有强持有它。

如果上面代码修改成:

func sing() -> () -> Void {
    let taylor = Singer()

    let singing = { [weak taylor] in
        taylor!.playSong()
        return
    }

    return singing
}

会引发崩溃,因为taylornil

无主引用

weak对应的是unowned,其行为更像是隐式解包可选项。就像弱引用一样,无主引用允许值在未来的任何时候都变为nil。但是,您可以使用它们,就像它们总是在那里一样 --你不需要解包可选项

func sing() -> () -> Void {
    let taylor = Singer()

    let singing = { [unowned taylor] in
        taylor.playSong()
        return
    }

    return singing
}

这里会发生崩溃,与我们之前强制解包类似:unowned taylor 告诉我们taylor会一直存在闭包的生命周期内,但实际上,taylor几乎立即被销毁,所以会崩溃

常见问题

当使用闭包捕获时,人们常常遇到四个问题:

  1. 当闭包接受参数时,他们不确定在何处使用捕获列表。
  2. 它们会产生循环引用,导致内存被消耗。
  3. 他们无意中使用强引用,特别是在使用多个捕获时。
  4. 他们复制闭包,并共享捕获的数据。

让我们通过简单的代码,看看都会发生什么

捕获列表与参数在一起

当你第一次开始使用捕获列表时,这是一个常见的问题,但幸运的是,Swift为我们做了规定。

当一起使用捕获列表和闭包参数时,捕获列表必须始终首先出现,然后单词in来标记闭包体的开始 - 尝试将其放在闭包参数之后将阻止代码编译。

writeToLog { [weak self] user, message in 
    self?.addToLog("\(user) triggered event: \(message)")
}

循环引用

当A持有B,同时B持有A,称之为循环引用

创建一个House类,有一个属性(闭包),一个方法,一个销毁器,当销毁时打印一条消息

class House {
    var ownerDetails: (() -> Void)?

    func printDetails() {
        print("This is a great house.")
    }

    deinit {
        print("I'm being demolished!")
    }
}

这有一个类似的类Owner,不同的是属性(闭包)

class Owner {
    var houseDetails: (() -> Void)?

    func printDetails() {
        print("I own a house.")
    }

    deinit {
        print("I'm dying!")
    }
}

我们在doblock中创建两个类的示例,我们不需要catch,确保在}之前会销毁

print("Creating a house and an owner")

do {
    let house = House()
    let owner = Owner()
}

print("Done")

//Creating a house and an owner
//I’m dying!
//I'm being demolished!
//Done

现在我们创建一个循环引用

print("Creating a house and an owner")

do {
    let house = House()
    let owner = Owner()
    house.ownerDetails = owner.printDetails
    owner.houseDetails = house.printDetails
}

print("Done")
//Creating a house and an owner
//Done

销毁器中的信息不会被打印,这是因为 house有一个属性指向owner,同时owner有一个属性指向house,所以他们不能被安全销毁,会导致内存不能释放,称之为内存泄露,会降低系统性能甚至应用终止

为解决这个问题,我们需要创建一个新的闭包,使用弱引用

print("Creating a house and an owner")

do {
    let house = House()
    let owner = Owner()
    house.ownerDetails = { [weak owner] in owner?.printDetails() }
    owner.houseDetails = { [weak house] in house?.printDetails() }
}

print("Done")

没有必要将这两个值都使用弱引用 - 重要的是至少有一个值,因为它允许Swift在必要时销毁它们。

意外强引用

Swift默认为强引用,这可能会导致无意中的问题

func sing() -> () -> Void {
    let taylor = Singer()
    let adele = Singer()

    let singing = { [unowned taylor, adele] in
        taylor.playSong()
        adele.playSong()
        return
    }

    return singing
}

现在我们有两个值被闭包捕获,并且两个值在闭包内使用方式相同,但是,只有taylor被无主引用,--adele被强引用,因为unowned关键字被使用必须放在每个捕获值前面

如果要两个值都无主引用

[unowned taylor, unowned adele]

Swift确实提供了一些防止意外捕获的措施,但是有限的:如果你在一个闭包中使用self,Swift会强制你选择使用self.或者self?让你的意图更清晰

在Swift中使用隐式self会发生很多事,比如,这个初始化程序调用playSong(),真正意义是self.playSong()---self由上下文隐含

class Singer {
    init() {
        playSong()
    }

    func playSong() {
        print("Shake it off!")
    }
}

swift不会让你在闭包内使用隐含self,有助于减少循环引用

闭包复制

闭包会和它的复制闭包共享捕获数据

var numberOfLinesLogged = 0

let logger1 = {
    numberOfLinesLogged += 1
    print("Lines logged: \(numberOfLinesLogged)")
}

logger1()

let logger2 = logger1
logger2()
logger1()
logger2()

//1
//2
//3
//4

什么时候使用强引用,什么时候使用弱引用,什么时候使用无主引用

  1. 如果你确定你的捕获值永远不会消失,而闭包有可能被调用,你可以使用unowned无主引用。这实际上只适用于weak会导致使用烦恼的少数几次,但可以在闭包内使用guard let修饰弱引用变量
  2. 如果有循环引用的情况,那么两个中的一个应该使用弱引用,通常是首先被销毁的一个,所以如果视图控制器A呈现视图控制器B,则视图控制器B可能将弱引用持有A。
  3. 如果不会发生循环引用,你可以使用强引用,例如执行动画不会在动画闭包内引起循环引用.所以你可以使用强引用



作者:1eb926af0289
链接:https://www.jianshu.com/p/37a62bada107
来源:简书
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值