1. 將value定義為struct節(jié)省內(nèi)存

1. 消除指針引用

當(dāng) map 的 value 是 struct 類型時(shí)，數(shù)據(jù)會(huì)直接存儲(chǔ)在 map 中，而不是通過指針引用。這可以減少內(nèi)存分配的開銷和 GC（垃圾回收）的負(fù)擔(dān)。

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"}

在第二個(gè)示例中，map 中存儲(chǔ)的是指向 User 結(jié)構(gòu)體的指針，這意味著除了存儲(chǔ)指針本身外，還需要額外的內(nèi)存來存儲(chǔ) User 結(jié)構(gòu)體，并且會(huì)增加 GC 的負(fù)擔(dān)。

2. 避免內(nèi)存碎片化

存儲(chǔ)指針時(shí)，由于指針可能指向堆中的不同位置，這會(huì)導(dǎo)致內(nèi)存碎片化，增加了內(nèi)存使用的不確定性。而存儲(chǔ) struct 使得數(shù)據(jù)更緊湊，減少了碎片化。

3. 更高的緩存命中率

由于 struct 的數(shù)據(jù)是緊湊存儲(chǔ)的，相對(duì)于存儲(chǔ)指針，struct 的數(shù)據(jù)更可能在相鄰的內(nèi)存位置。這增加了 CPU 緩存的命中率，從而提高了性能。

示例：節(jié)約內(nèi)存

下面是一個(gè)示例，展示了如何通過定義 struct 類型來節(jié)約內(nèi)存：

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實(shí)現(xiàn)對(duì)比

map[int]bool{}

在這種情況下，map 的 value 類型是 bool。每個(gè)鍵會(huì)占用一個(gè) bool 類型的空間（通常是一個(gè)字節(jié)）。

set := make(map[int]bool)
set[1] = true
set[2] = true

map[int]struct{}{}

在這種情況下，map 的 value 類型是空的 struct。空的 struct 不占用任何內(nèi)存，因此每個(gè)鍵只占用鍵本身的內(nèi)存。

set := make(map[int]struct{})
set[1] = struct{}{}
set[2] = struct{}{}

內(nèi)存使用對(duì)比

map[int]bool{} 會(huì)比 map[int]struct{}{} 使用更多的內(nèi)存，因?yàn)?bool 類型需要存儲(chǔ)一個(gè)字節(jié)（在實(shí)際應(yīng)用中可能會(huì)有額外的內(nèi)存對(duì)齊和管理開銷），而 struct{} 是空的，不會(huì)增加任何內(nèi)存開銷。

示例代碼對(duì)比內(nèi)存使用

以下是一個(gè)示例代碼，比較這兩種 map 類型的內(nèi)存使用情況：

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
}

結(jié)果

運(yùn)行上述代碼，你會(huì)發(fā)現(xiàn)使用 struct 作為 value 的內(nèi)存使用量明顯小于使用指針作為 value 的內(nèi)存使用量。這是因?yàn)椋?/p>

• 減少了指針的存儲(chǔ)開銷。
• 減少了額外的堆內(nèi)存分配。
• 降低了 GC 的負(fù)擔(dān)，因?yàn)?struct 的內(nèi)存管理更簡單，不涉及指針的追蹤和回收。

2. 哈希分桶的結(jié)構(gòu)

1. 哈希計(jì)算

當(dāng)我們向map中插入一個(gè)鍵值對(duì)，首先對(duì)鍵進(jìn)行哈希計(jì)算。Go內(nèi)置了哈希函數(shù)來計(jì)算鍵的哈希值。哈希值是一個(gè)64位的整數(shù)。

2. 分桶依據(jù)

Go 中的 map 是分成多個(gè)桶 (bucket) 來存儲(chǔ)的。桶的數(shù)量通常是 2 的冪次，這樣可以方便地通過位運(yùn)算來定位到具體的桶。哈希值的高八位和低八位分別用于分桶和桶內(nèi)定位：

• 高八位 (top 8 bits)：用于決定哈希表中的桶位置。
• 低八位 (low 8 bits)：用于桶內(nèi)查找。

3. 桶 (Bucket) 結(jié)構(gòu)

每個(gè)桶中可以存儲(chǔ) 8 個(gè)鍵值對(duì)。當(dāng)某個(gè)桶中的元素超過 8 個(gè)時(shí)，Go 會(huì)使用溢出桶來存儲(chǔ)額外的鍵值對(duì)。桶的結(jié)構(gòu)如下：

type bmap struct {
    tophash [bucketCnt]uint8
    keys    [bucketCnt]keyType
    values  [bucketCnt]valueType
    overflow *bmap
}

tophash：存儲(chǔ)鍵的哈希值的高八位。

keys：存儲(chǔ)鍵。

values：存儲(chǔ)對(duì)應(yīng)的值。

overflow：指向溢出桶的指針。

4. 插入過程

當(dāng)插入一個(gè)鍵值對(duì)時(shí)，過程如下：

1. 計(jì)算哈希值：對(duì)鍵進(jìn)行哈希計(jì)算得到哈希值 hash。
2. 定位桶：通過 hash >> (64 - B)（B 是桶的數(shù)量的對(duì)數(shù)）得到桶的索引 index。
3. 桶內(nèi)查找：通過 hash & (bucketCnt - 1) 得到桶內(nèi)索引。然后通過對(duì)比 tophash 數(shù)組中的值來定位到具體的鍵值對(duì)存儲(chǔ)位置。
4. 存儲(chǔ)鍵值對(duì)：將鍵值對(duì)存儲(chǔ)到相應(yīng)的位置，如果當(dāng)前桶已滿，則分配新的溢出桶來存儲(chǔ)額外的鍵值對(duì)。

5. 查找過程

查找的過程與插入類似：

查找的過程與插入類似：

1. 計(jì)算哈希值：對(duì)鍵進(jìn)行哈希計(jì)算得到哈希值 hash。
2. 定位桶：通過 hash >> (64 - B) 得到桶的索引 index。
3. 桶內(nèi)查找：通過 hash & (bucketCnt - 1) 得到桶內(nèi)索引，然后在相應(yīng)的 bmap 中查找 tophash 和 keys 數(shù)組中匹配的鍵。如果在當(dāng)前桶中沒有找到，則繼續(xù)查找溢出桶。

3. map擴(kuò)容過程

1. 擴(kuò)容觸發(fā)條件

擴(kuò)容通常在以下兩種情況下觸發(fā)：

擴(kuò)容通常在以下兩種情況下觸發(fā)：

1. 裝載因子過高：裝載因子（load factor）是 map 中元素?cái)?shù)量與桶數(shù)量的比值。Go 語言中的裝載因子閾值通常為 6.5，當(dāng)裝載因子超過這個(gè)值時(shí)會(huì)觸發(fā)擴(kuò)容。
2. 溢出桶過多：當(dāng)溢出桶的數(shù)量過多時(shí)，也會(huì)觸發(fā)擴(kuò)容。

2. 擴(kuò)容過程的具體步驟

1. 初始化新的桶數(shù)組： 在需要擴(kuò)容時(shí)，Go 會(huì)分配一個(gè)新的桶數(shù)組，其大小通常是舊桶數(shù)組的兩倍，并設(shè)置相關(guān)的元數(shù)據(jù)以指示 map 正在進(jìn)行擴(kuò)容。
2. 標(biāo)記遷移狀態(tài)： 在 map 的內(nèi)部結(jié)構(gòu)中，會(huì)有一個(gè)標(biāo)志位（rehash index）指示當(dāng)前已經(jīng)遷移的桶位置。初始值為 0。
3. 遷移部分?jǐn)?shù)據(jù)： 在每次對(duì) map 進(jìn)行插入或查找操作時(shí)，會(huì)順便遷移一部分舊桶中的數(shù)據(jù)到新桶中。每次遷移一個(gè)或多個(gè)桶，具體數(shù)量取決于操作的復(fù)雜度。
4. 更新 rehash index： 遷移完成后，更新 rehash index，以便下次操作繼續(xù)遷移下一個(gè)桶中的數(shù)據(jù)。
5. 完成擴(kuò)容： 當(dāng)所有舊桶的數(shù)據(jù)都遷移到新桶后，更新 map 的元數(shù)據(jù)，指向新的桶數(shù)組，并將擴(kuò)容狀態(tài)標(biāo)志位清除。

4. recover map的panic

panic 和 recover 的工作機(jī)制

1. panic：
   • panic 用于引發(fā)一個(gè)恐慌，通常在遇到無法恢復(fù)的嚴(yán)重錯(cuò)誤時(shí)使用。
   • 當(dāng) panic 被調(diào)用時(shí)，程序的正常執(zhí)行流程會(huì)被中斷，并開始沿著調(diào)用棧向上展開，逐層調(diào)用函數(shù)的 defer 語句，直到遇到 recover 或者程序崩潰。
2. recover：
   • recover 用于恢復(fù)程序的正常執(zhí)行，通常在 defer 函數(shù)中調(diào)用。
   • 如果在 defer 語句中調(diào)用了 recover，并且當(dāng)前棧幀處于恐慌狀態(tài)，那么 recover 會(huì)捕獲這個(gè)恐慌，停止棧的展開，并返回傳給 panic 的值。
   • 如果不在恐慌狀態(tài)下調(diào)用 recover，它會(huì)返回 nil，不做任何處理。

在 Go 語言中，panic 和 recover 是用來處理異常情況和錯(cuò)誤恢復(fù)的兩種機(jī)制。理解它們的工作原理對(duì)于編寫健壯的 Go 代碼非常重要。以下是對(duì) panic 和 recover 機(jī)制的詳細(xì)解釋以及它們在 map 中的應(yīng)用。

panic 和 recover 的工作機(jī)制

1. panic：
   • panic 用于引發(fā)一個(gè)恐慌，通常在遇到無法恢復(fù)的嚴(yán)重錯(cuò)誤時(shí)使用。
   • 當(dāng) panic 被調(diào)用時(shí)，程序的正常執(zhí)行流程會(huì)被中斷，并開始沿著調(diào)用棧向上展開，逐層調(diào)用函數(shù)的 defer 語句，直到遇到 recover 或者程序崩潰。
2. recover：
   • recover 用于恢復(fù)程序的正常執(zhí)行，通常在 defer 函數(shù)中調(diào)用。
   • 如果在 defer 語句中調(diào)用了 recover，并且當(dāng)前棧幀處于恐慌狀態(tài)，那么 recover 會(huì)捕獲這個(gè)恐慌，停止棧的展開，并返回傳給 panic 的值。
   • 如果不在恐慌狀態(tài)下調(diào)用 recover，它會(huì)返回 nil，不做任何處理。

在 map 中使用 panic 和 recover

在 Go 的 map 中，某些操作（如并發(fā)讀寫未加鎖的 map）會(huì)引發(fā) panic。這些 panic 可以被 recover 捕獲和處理，以防止程序崩潰。

package main

import (
    "fmt"
)

func main() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()

    // 創(chuàng)建一個(gè) map
    m := make(map[string]string)

    // 引發(fā) panic 的操作
    causePanic(m)

    fmt.Println("This line will be executed because panic was recovered.")
}

func causePanic(m map[string]string) {
    // 這里嘗試并發(fā)訪問 map，可能會(huì)引發(fā) panic
    // 模擬并發(fā)問題，直接引發(fā) panic
    panic("simulated map access panic")
}

5. map是如何檢測到自己處于競爭狀態(tài)

在 Go 語言中，map 的競爭狀態(tài)（concurrent access）指的是多個(gè) goroutine 同時(shí)讀寫同一個(gè) map 而沒有適當(dāng)?shù)耐奖Ｗo(hù)。Go 內(nèi)置的 map 類型在并發(fā)讀寫時(shí)會(huì)引發(fā) panic，以防止數(shù)據(jù)競爭和未定義行為。這種檢測主要是通過 Go 編譯器和運(yùn)行時(shí)的實(shí)現(xiàn)來完成的，而不是底層硬件直接支持的功能。

競爭檢測機(jī)制

1. 編譯器插樁：
   • 在編譯時(shí)，Go 編譯器會(huì)在對(duì) map 進(jìn)行讀寫操作的代碼位置插入特定的檢測代碼。這些檢測代碼在運(yùn)行時(shí)檢查 map 是否處于并發(fā)訪問狀態(tài)。
2. 運(yùn)行時(shí)檢查：
   • 運(yùn)行時(shí)的檢測代碼會(huì)追蹤 map 的訪問。當(dāng)檢測到多個(gè) goroutine 同時(shí)對(duì) map 進(jìn)行讀寫操作時(shí)，會(huì)引發(fā) panic。具體來說，Go 運(yùn)行時(shí)會(huì)記錄每個(gè) map 的訪問情況，如果檢測到并發(fā)訪問沒有通過同步機(jī)制（如 sync.Mutex），就會(huì)引發(fā) panic。

package main

import (
    "fmt"
    "sync"
)

func main() {
    m := make(map[int]int)
    var wg sync.WaitGroup
    var mu sync.Mutex

    // 啟動(dòng)多個(gè) goroutine 并發(fā)寫 map，未加鎖保護(hù)會(huì)引發(fā) panic
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            // 取消注釋以下行，查看未加鎖保護(hù)的并發(fā)寫操作
            // m[i] = i

            // 使用互斥鎖保護(hù)并發(fā)寫操作
            mu.Lock()
            m[i] = i
            mu.Unlock()
        }(i)
    }

    wg.Wait()

    // 打印 map 內(nèi)容
    mu.Lock()
    for k, v := range m {
        fmt.Printf("key: %d, value: %d\n", k, v)
    }
    mu.Unlock()
}

6. sync.Map和map加鎖的區(qū)別

1. • 使用場景：
     • sync.Map 適用于讀多寫少的并發(fā)場景，簡單且高效。
     • 使用 sync.Mutex 或 sync.RWMutex 保護(hù)普通 map 適用于需要復(fù)雜并發(fā)控制或?qū)懖僮鬏^多的場景。
   • 性能：
     • sync.Map 在讀多寫少的情況下性能優(yōu)越，但在寫操作頻繁時(shí)性能可能不如使用互斥鎖保護(hù)的普通 map。
     • 使用 sync.Mutex 或 sync.RWMutex 可以在讀寫操作間提供更好的性能平衡，尤其是在寫操作較多時(shí)。
   • 復(fù)雜性：
     • sync.Map 封裝了并發(fā)控制，使用簡單，不需要手動(dòng)加鎖。
     • 使用 sync.Mutex 或 sync.RWMutex 需要手動(dòng)加鎖解鎖，代碼相對(duì)復(fù)雜，但更靈活。
   • 方法支持：
     • sync.Map 提供了一些特殊的方法（如 LoadOrStore、Range），方便特定場景下的使用。
     • 使用 sync.Mutex 或 sync.RWMutex 保護(hù)的普通 map 可以自由定義自己的方法，更靈活，但需要更多的代碼。

以上就是詳解Golang中使用map時(shí)的注意問題的詳細(xì)內(nèi)容，更多關(guān)于Golang使用map的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

最新評(píng)論