我要评论1. 将value定义为struct节省内存
1. 消除指针引用
当 map 的 value 是 struct 类型时，数据会直接存储在 map 中，而不是通过指针引用。这可以减少内存分配的开销和 gc（垃圾回收）的负担。
type user struct {
id int
name string
}
m := make(map[string]user)
m["user1"] = user{id: 1, name: "john"}
// example with pointer to struct
m2 := make(map[string]*user)
m2["user1"] = &user{id: 1, name: "john"}
在第二个示例中，map 中存储的是指向 user 结构体的指针，这意味着除了存储指针本身外，还需要额外的内存来存储 user 结构体，并且会增加 gc 的负担。
2. 避免内存碎片化
存储指针时，由于指针可能指向堆中的不同位置，这会导致内存碎片化，增加了内存使用的不确定性。而存储 struct 使得数据更紧凑，减少了碎片化。
3. 更高的缓存命中率
由于 struct 的数据是紧凑存储的，相对于存储指针，struct 的数据更可能在相邻的内存位置。这增加了 cpu 缓存的命中率，从而提高了性能。
示例：节约内存
下面是一个示例，展示了如何通过定义 struct 类型来节约内存：
package main
import (
"fmt"
"runtime"
)
type user struct {
id int
name string
}
func main() {
// 使用 struct 作为 value
users := make(map[string]user)
for i := 0; i < 1000000; i++ {
users[fmt.sprintf("user%d", i)] = user{id: i, name: fmt.sprintf("name%d", i)}
}
printmemusage("with struct values")
// 使用指针作为 value
userptrs := make(map[string]*user)
for i := 0; i < 1000000; i++ {
userptrs[fmt.sprintf("user%d", i)] = &user{id: i, name: fmt.sprintf("name%d", i)}
}
printmemusage("with pointer values")
}
func printmemusage(label string) {
var m runtime.memstats
runtime.readmemstats(&m)
fmt.printf("%s: alloc = %v mib\n", label, btomb(m.alloc))
}
func btomb(b uint64) uint64 {
return b / 1024 / 1024
}
4. set实现对比
map[int]bool{}
在这种情况下，map 的 value 类型是 bool。每个键会占用一个 bool 类型的空间（通常是一个字节）。
set := make(map[int]bool) set[1] = true set[2] = true
map[int]struct{}{}
在这种情况下，map 的 value 类型是空的 struct。空的 struct 不占用任何内存，因此每个键只占用键本身的内存。
set := make(map[int]struct{})
set[1] = struct{}{}
set[2] = struct{}{}
内存使用对比
map[int]bool{} 会比 map[int]struct{}{} 使用更多的内存，因为 bool 类型需要存储一个字节（在实际应用中可能会有额外的内存对齐和管理开销），而 struct{} 是空的，不会增加任何内存开销。
示例代码对比内存使用
以下是一个示例代码，比较这两种 map 类型的内存使用情况：
package main
import (
"fmt"
"runtime"
)
func main() {
// 使用 bool 作为 value
boolmap := make(map[int]bool)
for i := 0; i < 1000000; i++ {
boolmap[i] = true
}
printmemusage("with bool values")
// 使用 struct 作为 value
structmap := make(map[int]struct{})
for i := 0; i < 1000000; i++ {
structmap[i] = struct{}{}
}
printmemusage("with struct values")
}
func printmemusage(label string) {
var m runtime.memstats
runtime.readmemstats(&m)
fmt.printf("%s: alloc = %v mib\n", label, btomb(m.alloc))
}
func btomb(b uint64) uint64 {
return b / 1024 / 1024
}
结果
运行上述代码，你会发现使用 struct 作为 value 的内存使用量明显小于使用指针作为 value 的内存使用量。这是因为：
- 减少了指针的存储开销。
- 减少了额外的堆内存分配。
- 降低了 gc 的负担，因为 struct 的内存管理更简单，不涉及指针的追踪和回收。
2. 哈希分桶的结构
1. 哈希计算
当我们向map中插入一个键值对，首先对键进行哈希计算。go内置了哈希函数来计算键的哈希值。哈希值是一个64位的整数。
2. 分桶依据
go 中的 map 是分成多个桶 (bucket) 来存储的。桶的数量通常是 2 的幂次，这样可以方便地通过位运算来定位到具体的桶。哈希值的高八位和低八位分别用于分桶和桶内定位：
- 高八位 (top 8 bits)：用于决定哈希表中的桶位置。
- 低八位 (low 8 bits)：用于桶内查找。
3. 桶 (bucket) 结构
每个桶中可以存储 8 个键值对。当某个桶中的元素超过 8 个时，go 会使用溢出桶来存储额外的键值对。桶的结构如下：
type bmap struct {
tophash [bucketcnt]uint8
keys [bucketcnt]keytype
values [bucketcnt]valuetype
overflow *bmap
}
tophash：存储键的哈希值的高八位。
keys：存储键。
values：存储对应的值。
overflow：指向溢出桶的指针。
4. 插入过程
当插入一个键值对时，过程如下：
- 计算哈希值：对键进行哈希计算得到哈希值
hash。 - 定位桶：通过
hash >> (64 - b)（b是桶的数量的对数）得到桶的索引index。 - 桶内查找：通过
hash & (bucketcnt - 1)得到桶内索引。然后通过对比tophash数组中的值来定位到具体的键值对存储位置。 - 存储键值对：将键值对存储到相应的位置，如果当前桶已满，则分配新的溢出桶来存储额外的键值对。
5. 查找过程
查找的过程与插入类似：
查找的过程与插入类似：
- 计算哈希值：对键进行哈希计算得到哈希值
hash。 - 定位桶：通过
hash >> (64 - b)得到桶的索引index。 - 桶内查找：通过
hash & (bucketcnt - 1)得到桶内索引，然后在相应的bmap中查找tophash和keys数组中匹配的键。如果在当前桶中没有找到，则继续查找溢出桶。
3. map扩容过程
1. 扩容触发条件
扩容通常在以下两种情况下触发：
扩容通常在以下两种情况下触发：
- 装载因子过高：装载因子（load factor）是 map 中元素数量与桶数量的比值。go 语言中的装载因子阈值通常为 6.5，当装载因子超过这个值时会触发扩容。
- 溢出桶过多：当溢出桶的数量过多时，也会触发扩容。
2. 扩容过程的具体步骤
- 初始化新的桶数组： 在需要扩容时，go 会分配一个新的桶数组，其大小通常是旧桶数组的两倍，并设置相关的元数据以指示 map 正在进行扩容。
- 标记迁移状态： 在 map 的内部结构中，会有一个标志位（rehash index）指示当前已经迁移的桶位置。初始值为 0。
- 迁移部分数据： 在每次对 map 进行插入或查找操作时，会顺便迁移一部分旧桶中的数据到新桶中。每次迁移一个或多个桶，具体数量取决于操作的复杂度。
- 更新 rehash index： 迁移完成后，更新 rehash index，以便下次操作继续迁移下一个桶中的数据。
- 完成扩容： 当所有旧桶的数据都迁移到新桶后，更新 map 的元数据，指向新的桶数组，并将扩容状态标志位清除。
4. recover map的panic
panic 和 recover 的工作机制
- panic：
panic用于引发一个恐慌，通常在遇到无法恢复的严重错误时使用。- 当
panic被调用时，程序的正常执行流程会被中断，并开始沿着调用栈向上展开，逐层调用函数的defer语句，直到遇到recover或者程序崩溃。
- recover：
recover用于恢复程序的正常执行，通常在defer函数中调用。- 如果在
defer语句中调用了recover，并且当前栈帧处于恐慌状态，那么recover会捕获这个恐慌，停止栈的展开，并返回传给panic的值。 - 如果不在恐慌状态下调用
recover，它会返回nil，不做任何处理。
在 go 语言中，panic 和 recover 是用来处理异常情况和错误恢复的两种机制。理解它们的工作原理对于编写健壮的 go 代码非常重要。以下是对 panic 和 recover 机制的详细解释以及它们在 map 中的应用。
panic 和 recover 的工作机制
- panic：
panic用于引发一个恐慌，通常在遇到无法恢复的严重错误时使用。- 当
panic被调用时，程序的正常执行流程会被中断，并开始沿着调用栈向上展开，逐层调用函数的defer语句，直到遇到recover或者程序崩溃。
- recover：
recover用于恢复程序的正常执行，通常在defer函数中调用。- 如果在
defer语句中调用了recover，并且当前栈帧处于恐慌状态，那么recover会捕获这个恐慌，停止栈的展开，并返回传给panic的值。 - 如果不在恐慌状态下调用
recover，它会返回nil，不做任何处理。
在 map 中使用 panic 和 recover
在 go 的 map 中，某些操作（如并发读写未加锁的 map）会引发 panic。这些 panic 可以被 recover 捕获和处理，以防止程序崩溃。
package main
import (
"fmt"
)
func main() {
defer func() {
if r := recover(); r != nil {
fmt.println("recovered from panic:", r)
}
}()
// 创建一个 map
m := make(map[string]string)
// 引发 panic 的操作
causepanic(m)
fmt.println("this line will be executed because panic was recovered.")
}
func causepanic(m map[string]string) {
// 这里尝试并发访问 map，可能会引发 panic
// 模拟并发问题，直接引发 panic
panic("simulated map access panic")
}
5. map是如何检测到自己处于竞争状态
在 go 语言中，map 的竞争状态（concurrent access）指的是多个 goroutine 同时读写同一个 map 而没有适当的同步保护。go 内置的 map 类型在并发读写时会引发 panic，以防止数据竞争和未定义行为。这种检测主要是通过 go 编译器和运行时的实现来完成的，而不是底层硬件直接支持的功能。
竞争检测机制
- 编译器插桩：
- 在编译时，go 编译器会在对 map 进行读写操作的代码位置插入特定的检测代码。这些检测代码在运行时检查 map 是否处于并发访问状态。
- 运行时检查：
- 运行时的检测代码会追踪 map 的访问。当检测到多个 goroutine 同时对 map 进行读写操作时，会引发 panic。具体来说，go 运行时会记录每个 map 的访问情况，如果检测到并发访问没有通过同步机制（如
sync.mutex），就会引发 panic。
- 运行时的检测代码会追踪 map 的访问。当检测到多个 goroutine 同时对 map 进行读写操作时，会引发 panic。具体来说，go 运行时会记录每个 map 的访问情况，如果检测到并发访问没有通过同步机制（如
package main
import (
"fmt"
"sync"
)
func main() {
m := make(map[int]int)
var wg sync.waitgroup
var mu sync.mutex
// 启动多个 goroutine 并发写 map，未加锁保护会引发 panic
for i := 0; i < 10; i++ {
wg.add(1)
go func(i int) {
defer wg.done()
// 取消注释以下行，查看未加锁保护的并发写操作
// m[i] = i
// 使用互斥锁保护并发写操作
mu.lock()
m[i] = i
mu.unlock()
}(i)
}
wg.wait()
// 打印 map 内容
mu.lock()
for k, v := range m {
fmt.printf("key: %d, value: %d\n", k, v)
}
mu.unlock()
}
6. sync.map和map加锁的区别
- 使用场景：
sync.map适用于读多写少的并发场景，简单且高效。- 使用
sync.mutex或sync.rwmutex保护普通 map 适用于需要复杂并发控制或写操作较多的场景。
- 性能：
sync.map在读多写少的情况下性能优越，但在写操作频繁时性能可能不如使用互斥锁保护的普通 map。- 使用
sync.mutex或sync.rwmutex可以在读写操作间提供更好的性能平衡，尤其是在写操作较多时。
- 复杂性：
sync.map封装了并发控制，使用简单，不需要手动加锁。- 使用
sync.mutex或sync.rwmutex需要手动加锁解锁，代码相对复杂，但更灵活。
- 方法支持：
sync.map提供了一些特殊的方法（如loadorstore、range），方便特定场景下的使用。- 使用
sync.mutex或sync.rwmutex保护的普通 map 可以自由定义自己的方法，更灵活，但需要更多的代码。
- 使用场景：
以上就是详解golang中使用map时的注意问题的详细内容，更多关于golang使用map的资料请关注代码网其它相关文章！
发表评论