Swift Talk:理解值类型

Sunxb
English

我们使用写时复制 copy on write 的思想,对 NSMutableData 进行封装,以此来理解我们的标准库的实现方式。

标准库中提供的所有的基本集合类型都是值类型,通过写时复制的思想保证了他的高效性。集合类型是我们比较常用到的数据类型,所以了解他的性能特性很重要,我们来一起看一下写时复制是如何工作的,并且尝试自己手动实现一个。

引用类型

举个例子,我们比较一下Swift的Data(结构体)和Foundation库中的NSMutableData(类)。首先我们使用一些字节数据来初始化 NSMutableData 实例。

var sampleBytes: [UInt8] = [0x0b,0xad,0xf0,0x0d]
let nsData = NSMutableData(bytes: sampleBytes, length: sampleBytes.count)

我们使用了 let 来声明 nsData,但是像 NSMutableData 这样的引用类型不受let/var 的控制。对于引用类型来说,用 let 声明代表 nsData 这个指针不能在指向别的内存,但是他指向的这个内存中的数据是可以变化的。也就是说我们依然可以往 nsData 中 append 数据。

nsData.append(sampleBytes, length: sampleBytes.count)

当我们再声明一个对象,改变其中一个对象,另一个对象也会发生变化。

let nsOtherData = nsData
nsData.append(sampleBytes, length: sampleBytes.count)
// nsOtherData 也会变

如果我们想产生一个独立的副本,我们需要使用 mutableCopy(返回一个 Any 类型),我们需要把返回值强转成我们需要的 NSMutableData 类型。

let nsOtherData = nsData.mutableCopy() as! NSMutableData
nsData.append(sampleBytes, length: sampleBytes.count)
// nsOtherData 不变

值类型

首先我们也是通过 sampleBytes 来初始化一个 Data。

let data = Data(bytes: sampleBytes, count: sampleBytes.count)

如果我们使用 let 关键字,那编译器就不会允许我们调用类型 append 这样的方法。所以如果要改变 data 的值,要使用 var 。

var data = Data(bytes: sampleBytes, count: sampleBytes.count)
data.append(contentsOf: sampleBytes)

Data 和 NSData 最主要的不同之处是:把值赋给另一个变量时或者作为参数传到方法中,Data 总是会生成一个新的副本,但是 NSData 只会生成一个新的引用,但是两个引用指向同一个内存区域。

当我们创建 Data 的一个副本的时候,他的所有的字段都会被复制,但是又不是立刻复制,因为 Data 内存有对实际内存空间的引用,所以当结构体被复制时,也只是会生成一个新的引用,只有我们对这个新的引用修改数据是,实际的数据才会被复制。

实现写时复制

我们自己实现一个 Data 类型来帮我们理解写时复制是如何工作的,我们内部使用 NSMutableData 来实际的存储数据(只是为了更快的完成,实际的Data 内部肯定是用到更底层的数据结构来存储数据)。改变数据的方法我们只实现一个 append 方法。

struct MyData {
    var data = NSMutableData()
    
    func append(_ bytes: [UInt8]) {
        data.append(bytes, length: bytes.count)
    }
}

我们可以创建一个 MyData

let data = MyData()

为了能更好的打印出 data 中存储的数据,我们可以让 MyData 实现 CustomDebugStringConvertible 协议。

extension MyData: CustomDebugStringConvertible {
    var debugDescription: String {
        return String(describing: data)
    }
}

现在我们可以调用 append 方法了。

data.append(sampleBytes)

但这是有问题的,首先我们的MyData是结构体,而且创建 data 使用的是let,我们不应该可以修改他的值。

而且看下面的代码,他的复制行为也是有问题的,在我们声明了一个新的引用时,并没有获得一个完全独立的副本。

var copy = data
copy.append(sampleBytes)

print(data)
print(copy)
// copy 调用 append, data 也会改变

所以说我们虽然创建了一个结构体,但是他并没有表现出值语义来。

目前,我们在把 data 赋给一个新的变量时,虽然他是所有字段都复制,但是我们MyData内部的 data 是一个 NSMutableData 引用类型,所以说 data 和 copy 这两个变量的值现在都包含对同一个 NSMutableData 实例的引用。

为了解决这个问题,我们要先处理写时复制的’写时‘问题。当我们在调用 append 方法添加数据时,我们要把内部进行实际存储功能的data进行深拷贝,此时 我们的 append 方法就必须加上 mutating 关键字,要不然编译器不允许修改结构体的变量。

struct MyData {
    var data = NSMutableData()
    
    mutating func append(_ bytes: [UInt8]) {
        print("make a copy")
        data = data.mutableCopy() as! NSMutableData
        data.append(bytes, length: bytes.count)
    }
}

现在我们要重新生成一个 var 类型的 data 来调用 append 方法,因为编译器不允许let 类型的调用带 mutating 关键字的方法。

var data = MyData()
var copy = data
copy.append(sampleBytes)

在我们继续之前,进行一个小的重构,并将生成 NSMutableData 实例副本的代码提取到一个单独的属性中。

struct MyData {
    var data = NSMutableData()
    var dataForWriting: NSMutableData {
        mutating get {
            print("make a copy")
            data = data.mutableCopy() as! NSMutableData
            return data
        }
    }
    
    mutating func append(_ bytes: [UInt8]) {
        dataForWriting.append(bytes, length: bytes.count)
    }
}

让写时复制更高效

目前我们的写时复制是非常简单的,就是每次当我们调用 append 的时候,都会拷贝,不管我们是不是这个实例的唯一持有者。

for _ in 0..<10 {
    data.append(sampleBytes)
}
// making a copy 会打印10次

其实真正需要执行复制操作的是当我们把data赋值给另一个变量后,这时调用append 方法,因为此时有两个引用,所以需要进行深拷贝。当拷贝结束后,这两个都是引用指向的都是完全独立的备份了,所以再一次调用时就不需要拷贝了。

所以说我们的MyData结构没有问题,但是多次拷贝会降低性能。我们可以使用 isKnownUniquelyReferenced 这个方法来帮助我们实现想要的效果。

var dataForWriting: NSMutableData {
    mutating get {
        if isKnownUniquelyReferenced(&data) {
            return data
        }
        print("make a copy")
        data = data.mutableCopy() as! NSMutableData
        return data
    }
}

虽然我们现在加上了 isKnownUniquelyReferenced 检查,但是运行一下测试代码还是会copy多次,那是因为 isKnownUniquelyReferenced 方法只是对Swift类型有效果,如果是传入的OC类型的对象,总是会返回false,所以我们应该使用一个Swift类型来包装一下这个data类型。

final class Box<A> {
    let unbox: A
    init(_ value: A) {
        self.unbox = value
    }
}

我们使用这个Box类来包装 NSMutableData , 最终我们的MyData 变成下面这样子

struct MyData {
    var data = Box(NSMutableData())
    var dataForWriting: NSMutableData {
        mutating get {
            if isKnownUniquelyReferenced(&data) {
                return data.unbox
            }
            print("make a copy")
            data = Box(data.unbox.mutableCopy() as! NSMutableData)
            return data.unbox
        }
    }
    
    mutating func append(_ bytes: [UInt8]) {
        dataForWriting.append(bytes, length: bytes.count)
    }
}

现在我们的代码只对 NSMutableData 实例copy一次。

var data = MyData()
var copy = data
for _ in 0..<10 {
    data.append(sampleBytes)
}
// Prints:
// making a copy 一次

标准库中数组和字典的实现方式其实也是类似的,只是他们用了更低级的数据结构来存储,我们这样手动实现一次写时复制,有助于我们更好理解他们内部的性能。

写时复制注意点

写时复制很高效,但是他不是适应于所有的场景,比如说我们上面的for循环是可以的,但是如果我们使用reduce来实现上面的循环,他就不起作用了。

(0..<10).reduce(data) { result, _ in
    var copy = result
    copy.append(sampleBytes)
    return copy
}

这个实现方式会生成 10 个副本,因为当我们调用 append 时,总是有两个变量——copy 和 result——引用指向同一个实例。

所以我们应该注意我们代码中那些产品大量不必要副本的地方,不过我们一般都不会这么写,所以说问题不大。

阅读 363

技术分享-持续学习
记录技术学习和进阶的过程
83 声望
329 粉丝
0 条评论
83 声望
329 粉丝
宣传栏