我们知道Swift中推荐使用具有值语义的结构体,而不是具有可变性的引用语义.
let arr = [1,2,4,3]
var arr2 = arr // 这一步会复制arr中的内容给arr2
Swift标准库中Array结构体是具有写时复制(copy-on-write)的.
如上代码在创建一个新Array变量并且将arr赋值给它的时候,会复制这个arr来确保它们各自独立. (这是我们平常的理解)
但是如上这种情况下,并没有对arr2进行任何的操作,arr2与arr独立开似乎并没有什么作用.这种情况下因为赋值进行复制一份内容是比较耗费性能的事.
所以通过写时复制要实现的就是,起初给arr2赋值后,arr和arr2的内容的内存地址是相同的.这两个数组共享了它们的存储部分.不过当我们改变arr2的时候这个内存会被检测到,这个时候再对这块内存的内容进行复制.. 因为复制操作只在必要的时候发生,节省了性能消耗.
来验证一下
按照"写时复制"的要求,上面代码 arr 和 arr2中的元素的内存地址是同一块的,
// 在两行代码后打断点,分别打印两个数组第一个元素的地址
(lldb) po withUnsafePointer(to: &arr[0], {$0})
▿ 0x000060400046a920
- pointerValue : 105827998804256
(lldb) po withUnsafePointer(to: &arr2[0], {$0})
▿ 0x000060400046a920
- pointerValue : 105827998804256
虽然arr和arr2是两个不同的结构体了,arr2的内容并没有真正复制一份.
当我们增加一段修改arr2的代码之后
let arr = [1,2,4,3]
var arr2 = arr
arr2[1] = 3
我们在代码执行后打印它们的第0个元素的地址
(lldb) po withUnsafePointer(to: &arr[0], {$0})
▿ 0x000060400026db60
- pointerValue : 105827996719968
(lldb) po withUnsafePointer(to: &arr2[0], {$0})
▿ 0x000060400026daa0
- pointerValue : 105827996719776
虽然我们修改的是数组中第一个元素,但是第0个元素和整个内容的地址都变了,可见它的内容确实在修改之前全部复制了一份..
自定义结构体实现写时复制
Swift标准库中的集合类型是已经实现了写时复制的.但是如果我们自己创建一个结构体,它并不免费具备这种特性.
struct MyData {
fileprivate(set) var data : NSMutableData
init(_ data: Data) {
self.data = NSMutableData(data: data).mutableCopy() as! NSMutableData
}
func append(_ otherData: Data) {
data.append(otherData)
}
}
模仿系统中Data集合的操作,我们自定义了一个MyData结构体..获取其中data数据是通过只读的data属性.
当我们创建下列代码:
let theData = Data(base64Encoded: "wAEP/w==")!
let aData = MyData(theData)
var bData = aData
bData.append(theData)
因为将aData赋值给bData的时候是进行的浅复制.所以MyData中的data对象本身不会被复制,而只有对象的引用会被复制.在给bData进行append操作后
po aData.data
<c0010fff c0010fff>
//// 我们发现aData也发生了变化
这不是我们想要的目的,我们现在只是创建了一个具有值语义的结构体.我们想要结构体在复制之后不会彼此间相互独立.并且在写入操作时候再进行必要的复制.
所以我们修改代码:
struct MyData {
fileprivate(set) var data : NSMutableData
fileprivate var dataForWriting: NSMutableData {
mutating get {
data = data.mutableCopy() as! NSMutableData
return data
}
}
init(_ data: Data) {
self.data = NSMutableData(data: data).mutableCopy() as! NSMutableData
}
mutating func append(_ otherData: Data) {
// 每次进行添加操作前调用dataForWriting的get方法
对data进行复制,来保证与之前的对象独立.
dataForWriting.append(otherData)
}
}
我们引入了一个dataForWriting计算型属性来间接修改data.而不是直接修改data. 每次调用append进行"写入"操作的时候便会调动这个计算属性对data复制一份. 如此这个结构体遍完全的具有了值语义.. 而且是在append的时候才进行的复制.
性能优化
但是每次进行append操作都会复制一次原先的data,这样显然是效率极低的. 如果我们已经发现属性中的data属性只有自己引用,修改它的值不会影响到其它任何结构体..那么我们完全就可以直接修改它不需要频繁的复制了.
在Swift中就有一个函数可以检测某一个引用的唯一性.将一个Swift类传递给这个函数,如果没有其它强引用变量指向它,函数将返回true,如果还有其它引用指向它则返回false..对于OC的类它会直接返回false.所以直接对NSmutableData使用这个函数没有意义..我们可以创建一个Swift类,来将任意的OC对象封装到这个类中..
// Swift的class容器,传入一个OC类型
class Box<T> {
var unbox: T
init(_ value: T) {
self.unbox = value
}
}
接着我们重构一下MyData类
struct MyData {
fileprivate(set) var data : Box<NSMutableData>
fileprivate var dataForWriting: NSMutableData {
mutating get {
// 检验 data是否是唯一引用
if !isKnownUniquelyReferenced(&data) {
data = Box(data.unbox.mutableCopy() as! NSMutableData)
}
return data.unbox
}
}
init(_ data: Data) {
self.data = Box(NSMutableData(data: data).mutableCopy() as! NSMutableData)
}
mutating func append(_ otherData: Data) {
dataForWriting.append(otherData)
}
}
看起来是麻烦了一点.不过这样才能保证结构体的高效操作..
let aData = MyData(theData)
var bData = aData
for _ in 0 ..< 5 {
bData.append(theData)
}
接着我们执行5次append操作..发现data的mutablecopy只执行了一次.因为拷贝一次后它的引用者也就只有这个结构体本身了.
虽然我们在创建结构体的时候大部分时候属性中都是一些值语义的..我们要确保结构体的不可变性.
