【Go语言精进之路】构建高效Go程序：了解map实现原理并高效使用

🔥 个人主页：空白诗****🔥 热门专栏：【Go语言精进之路】

文章目录

引言

在Go语言中，

map

是一种无序的键值对集合，它以其高效的查找、插入和删除操作而闻名。了解

map

的基本概念、特性和内部实现机制，对于编写高效且稳定的Go代码至关重要。本文将深入探讨

map

的各个方面，包括其初始化、基本操作、内部实现细节，并讨论为何在创建

map

时应尽量使用带有容量提示参数的做法。

---

一、什么是

map

1.1

map

的基本概念与特性

map

是Go语言中的一种内建引用类型，它表示一组无序的键值对集合。每个键值对用冒号“:”分隔，其中键（key）是唯一的，用于标识对应的值（value）。

map

允许我们根据特定的键快速检索、更新或删除对应的值。

在Go语言中，

map

对值（value）的数据类型没有特定限制，它可以是任意类型，包括基本类型、结构体、自定义类型等。但是，键（key）的类型有严格要求：key的类型必须可以通过“==”和“!=”操作符进行比较，这意味着键的类型需要是可比较的。因此，像函数、map和切片这样不可比较的类型不能作为map的键。

1.2 map的初始化与零值问题

需要注意的是，**

map

类型不支持“零值可用”，也就是说，未显式初始化的map变量其默认值为

nil

**。尝试对

nil

的

map

变量进行操作将会导致运行时错误（panic）。例如：

var m map[string]int// 此时m的值为nil// 下面的操作将会导致运行时panic，因为m未被初始化
m["key"]=1// panic: assignment to entry in nil map

为了避免这种情况，我们需要在使用

map

之前对其进行初始化。可以通过以下两种方式之一来初始化

map

：

1. 使用make函数初始化：

m :=make(map[string]int)
m["key"]=1// 现在这是安全的，因为m已经被初始化

1. 使用字面量初始化：

m :=map[string]int{"key":1}// 或者
m :=map[string]int{}
m["key"]=1// 同样是安全的，因为m已经被初始化

初始化后的

map

可以被安全地用于存储和检索键值对，而不会导致运行时错误。在Go程序中，

map

是非常有用的数据结构，特别适用于需要根据键快速查找、添加或删除相应值的场景。

1.3

map

作为引用类型的行为

和切片一样，**

map

也是引用类型。这意味着，当你将一个

map

类型的变量传递给函数时，实际上传递的是指向底层数据结构的指针，而不是整个数据结构的拷贝**。因此，将

map

类型变量作为函数参数传入不会有很大的性能消耗。

此外，由于在函数内部和外部引用的是同一个底层数据结构，所以在函数内部对

map

变量的修改（如添加、删除键值对或更新值）在函数外部也是可见的。这种特性使得

map

在需要在多个函数或方法间共享和修改数据时非常有用。

以下是一个示例，展示了在函数内部修改

map

，并在函数外部观察到这些修改：

package main

import"fmt"funcmodifyMap(m map[string]int){// 在函数内部修改map
    m["apple"]=5
    m["banana"]=10}funcmain(){// 初始化一个map
    fruitMap :=make(map[string]int)// 调用函数，传入map作为参数modifyMap(fruitMap)// 打印修改后的map，可以看到在modifyMap函数中所做的修改
    fmt.Println(fruitMap)// 输出: map[apple:5 banana:10]}

在这个例子中，

modifyMap

函数接收一个

map

作为参数，并在函数内部添加了两个键值对。当函数执行完毕后，

main

函数中的

fruitMap

已经被修改，反映了

modifyMap

函数中所做的更改。这是因为

map

是引用类型，

modifyMap

接收的是

fruitMap

的引用，因此对它的任何修改都会反映在原始

map

上。

---

二、

map

的基本操作

2.1 插入数据

当面对一个非

nil

的

map

类型变量时，我们可以向其中插入符合

map

类型定义的任意键值对。值得注意的是，如果试图插入的键（key）已经存在于

map

中，那么新的值将会覆盖旧的值。Go运行时会管理

map

内部的内存，因此，除非系统内存耗尽，否则我们不必担心向

map

中插入大量数据。

m :=make(map[string]int)
m["apple"]=5// 插入键值对 "apple": 5
m["apple"]=7// 更新键 "apple" 的值为 7，旧值5被覆盖
m["banana"]=10// 插入键值对 "banana": 10

在上述代码中，我们首先创建了一个从

string

类型到

int

类型的

map

。然后，我们插入了键值对

"apple": 5

。紧接着，我们尝试再次插入键

"apple"

，但这次赋予它一个新的值

7

。由于这个键已经存在于

map

中，因此旧的值

5

会被新的值

7

覆盖。最后，我们插入了一个新的键值对

"banana": 10

。

这种覆盖行为是

map

的一个重要特性，它允许我们根据需要更新存储在

map

中的值。在实际编程中，这一特性非常有用，比如当我们需要根据某些条件动态改变值时。

2.2 获取数据个数

要获取

map

中数据的个数，可以使用内置的

len()

函数。

count :=len(m)
fmt.Println("Number of items in map:", count)// 输出map中的元素个数

len(m)

返回

m

中当前存储的键值对数量。

2.3 查找和数据读取

可以根据键来查找和读取

map

中的数据。如果键不存在，则返回该类型的零值。

value, exists := m["apple"]// 查找键为"apple"的值，并检查键是否存在if exists {
    fmt.Println("The value of 'apple' is:", value)}else{
    fmt.Println("'apple' does not exist in the map.")}

使用

value, exists := m[key]

的格式可以同时获取键对应的值和该键是否存在。如果键存在，

exists

为

true

，并且

value

为该键对应的值；如果键不存在，

exists

为

false

，

value

为该类型的零值。

2.4 删除数据

要从

map

中删除一个键值对，可以使用

delete()

函数。

delete(m,"banana")// 删除键为"banana"的键值对

delete(m, key)

函数会从

m

中删除与

key

关联的键值对。如果

key

不存在，则

delete

什么也不做。

2.5 遍历数据

可以使用

range

关键字来遍历

map

中的所有键值对。

package main

import"fmt"funcmain(){
    m :=map[int]int{1:11,2:12,3:13,}
    fmt.Printf("{ ")for key, value :=range m {
        fmt.Printf("key: %d, value: %d  ", key, value)}
    fmt.Printf(" }\n")}

range m

会迭代

m

中的所有键值对，每次迭代都会返回当前的键和值。在上面的循环中，

key

和

value

分别被赋值为当前迭代的键和值，然后打印出来。

上面的输出结果非常理想，给我们的表象是迭代器按照

map

中的元素插入次序逐一遍历。那让我们再多遍历几次这个

map

：

package main

import"fmt"funcdoIteration(m map[int]int){
    fmt.Printf("{ ")for key, value :=range m {
        fmt.Printf("key: %d, value: %d  ", key, value)}
    fmt.Printf(" }\n")}funcmain(){
    m :=map[int]int{1:11,2:12,3:13,}for i :=0; i <3; i++{doIteration(m)}}

我们看见对同一

map

进行多次遍历，遍历的元素次序并不相同。这是因为Go运行时在初始化map迭代器时对起始位置做了随机处理。因此**千万不要依赖遍历

map

所得到的元素次序**。

---

三、map的内部实现

和切片相比，

map

类型的内部实现要复杂得多。Go运行时使用一张哈希表来实现抽象的

map

类型，运行时实现了

map

操作的所有功能，包括查找、插入、删除、遍历等。本文这里只做一些简单的介绍。

3.1 初始状态

在Go语言中，当一个

map

被初始化时，它会分配一个较小的内存空间来存储键值对数据。这个初始的内存空间包含一定数量的桶（buckets），每个桶能够存储一个或多个键值对。初始状态下，这些桶都是空的。

map

的初始化可以通过字面量、

make

函数或者直接使用

map

类型进行。例如：

// 使用字面量初始化
m1 :=map[string]int{"apple":5,"banana":10}// 使用make函数初始化
m2 :=make(map[string]int)// 直接声明map类型变量（需要后续进行初始化）var m3 map[string]int
m3 =make(map[string]int)

在初始化时，

map

会预留一定的空间以准备存储键值对，但这个初始空间相对较小。

3.2

map

扩容

当

map

中的元素数量增加，负载因子（已存储的键值对数量与桶的数量的比例）也会随之增加。当负载因子超过某个预定的阈值时，

map

会进行扩容以保证性能。

扩容过程中，

map

会创建一个更大的桶数组，并且重新计算所有现有键值对的哈希值，将它们重新分布到新的桶数组中。这个重新哈希和分布的过程是为了确保键值对能够更均匀地分散在新的桶中，从而减少哈希冲突并提高查找效率。

扩容是一个相对昂贵的操作，因为它涉及到内存分配和大量数据的迁移。因此，在实际使用中，如果可能的话，最好提前预估

map

的大小并一次性分配足够的空间。

3.3

map

并发

Go语言的

map

类型并不是并发安全的。这意味着如果多个goroutine同时对一个

map

进行读写操作，就可能导致数据竞争（data race）和不可预知的行为。

为了在并发环境中安全地使用

map

，有几种常见的解决方案：

1. 使用互斥锁（Mutex）：通过使用sync.Mutex或sync.RWMutex来同步对map的访问。在每次读写map之前，先获取锁，操作完成后再释放锁。
2. **使用sync.Map**：Go语言标准库提供了一个并发安全的map实现，即sync.Map。它内部使用了分段锁和其他优化技术来提供高效的并发访问。
3. 通道（Channel）：另一种方法是使用Go的通道来序列化对map的访问。通过将所有对map的操作都通过一个或多个通道来进行，可以确保在同一时间只有一个goroutine能够访问map。

在实际应用中，选择哪种并发控制方法取决于具体的使用场景和性能要求。对于简单的用例，使用互斥锁可能就足够了；而在需要高并发性能的场景中，

sync.Map

可能更为合适。

---

四、尽量使用cap参数创建map

由于扩容是一个相对昂贵的操作，因为它涉及到内存分配和大量数据的迁移，因此，如果可以的话我们最好对

map

使用规模做出粗略的估算，并使用

cap

参数对

map

实例进行初始化。

当你创建一个

map

而不指定容量时，Go 会自动为你分配一个初始的、未指定的容量。这个容量足以满足初始需求，并且随着

map

中元素的增加，Go 的运行时会自动管理其内部结构的大小调整，以容纳更多的元素。这是最常见也是最简单的初始化方式。

m :=make(map[string]int)

如果你在创建

map

时明确指定了

cap

参数，你是在给 Go 提供一个关于你期望

map

最终可能包含多少个键值对的提示。这有助于减少

map

在增长过程中需要重新分配内存的次数，从而提高效率，尤其是在你知道

map

大致会有多大时。但请注意，指定的

cap

是一个提示而不是严格的限制，

map

的实际容量可能会略高于指定的值，且

map

仍然可以在达到这个预设容量后继续增长。

m :=make(map[string]int,100)

优缺点分析：

• 不使用 cap：简化初始化过程，让Go自动管理容量，适用于大多数情况，特别是当你不确定map最终大小时。
• 使用 cap：通过预先估计map的大小，可以略微优化性能，减少动态扩容的次数，适合于明确知道或能估算map容量的场景。

选择是否使用

cap

主要取决于你对

map

最终规模的了解程度和对性能的特定需求。在不需要精确控制初始容量的情况下，省略

cap

是一个简洁且有效的方法。然而，如果你正处理大量数据且关心性能优化，明智地设定初始容量可以带来益处。

下面对两种初始化方式的性能进行对比：

package main

import"testing"const mapSize =10000funcBenchmarkMapInitWithoutCap(b *testing.B){for i :=0; i < b.N; i++{
        m :=make(map[int]int)for i :=0; i < mapSize; i++{
            m[i]= i
        }}}funcBenchmarkMapInitWithCap(b *testing.B){for i :=0; i < b.N; i++{
        m :=make(map[int]int, mapSize)for i :=0; i < mapSize; i++{
            m[i]= i
        }}}

BenchmarkMapInitWithoutCap

函数执行以下操作：

1. 它使用一个循环，该循环将运行b.N次，其中b.N是testing.B提供的，表示基准测试应该运行的次数。这是为了确保我们获得足够的数据点来平均性能测试结果，从而获得更准确的数据。
2. 在每次循环中，它创建一个新的map，没有指定初始容量（make(map[int]int)）。
3. 然后，它向这个map中插入mapSize（即10000）个键值对，其中键和值都是循环变量i。

这个基准测试的目的是测量在不指定初始容量的情况下，初始化并填充一个map的性能。

执行结果如下：

BenchmarkMapInitWithCap

函数与

BenchmarkMapInitWithoutCap

非常相似，但有一个关键区别：

1. 在创建map时，它使用make(map[int]int, mapSize)来指定一个初始容量提示，这个容量提示等于将要插入的键值对的数量（即10000）。

这个基准测试的目的是测量在指定了与将要插入的键值对数量相等的初始容量提示的情况下，初始化并填充一个map的性能。

下面是执行结果：

可以看出，使用

cap

参数的

map

实例的平均写性能是不使用

cap

参数的2倍。

---

五、总结

本文通过详细阐述了Go语言中

map

的基本概念、特性及其作为引用类型的行为，介绍了

map

的基本操作如插入、获取数据个数、查找、删除和遍历数据等。同时，深入剖析了

map

的内部实现，包括其初始状态、扩容机制以及并发问题。最后，本文强调了在使用

map

时，为了提高性能和减少内存重新分配的次数，应尽量在创建时提供合理的容量提示参数。通过全面理解

map

的工作原理和最佳实践，开发者可以更加有效地利用这一强大的数据结构来优化程序性能。