8、并发map：百万数据本地缓存，如何降延时减毛刺

package main

import (
    "fmt"
    "sync"
)

func main() {
    var m sync.Map
    m.Store("key1", "value1")
    m.Store("key2", 2)
    value, ok := m.Load("key1")
    if ok {
        fmt.Println("Value:", value)
    }
    m.Delete("key1")
    value, ok = m.Load("key1")
    if ok {
        fmt.Println("Value:", value)
    } else {
        fmt.Println("Key not found")
    }
}

type Map struct {
    mu Mutex
    read atomic.Pointer[readOnly] // 无锁读map
    dirty map[any]*entry // 加锁读写map
    misses int
}

// readOnly is an immutable struct stored atomically in the Map.read field.
type readOnly struct {
    m       map[any]*entry
    amended bool // true if the dirty map contains some key not in m.
}

// An entry is a slot in the map corresponding to a particular key.
type entry struct {
    p atomic.Pointer[any]
}

// Load returns the value stored in the map for a key, or nil if no
// value is present.
// The ok result indicates whether value was found in the map.
func (m *Map) Load(key any) (value any, ok bool) {
    read := m.loadReadOnly()
    e, ok := read.m[key]
    if !ok && read.amended {
        m.mu.Lock()
        // Avoid reporting a spurious miss if m.dirty got promoted while we were
        // blocked on m.mu. (If further loads of the same key will not miss, it's
        // not worth copying the dirty map for this key.)
        read = m.loadReadOnly()
        e, ok = read.m[key]
        if !ok && read.amended {
            e, ok = m.dirty[key]
            // Regardless of whether the entry was present, record a miss: this key
            // will take the slow path until the dirty map is promoted to the read
            // map.
            m.missLocked()
        }
        m.mu.Unlock()
    }
    if !ok {
        return nil, false
    }
    return e.load()
}

func (m *Map) missLocked() {
    m.misses++
    if m.misses < len(m.dirty) {
        return
    }
    m.read.Store(&readOnly{m: m.dirty})
    m.dirty = nil
    m.misses = 0
}

// Swap swaps the value for a key and returns the previous value if any.
// The loaded result reports whether the key was present.
func (m *Map) Swap(key, value any) (previous any, loaded bool) {
    ...
    m.mu.Lock()
    if !read.amended {
        // We're adding the first new key to the dirty map.
        // Make sure it is allocated and mark the read-only map as incomplete.
        m.dirtyLocked()
        m.read.Store(&readOnly{m: read.m, amended: true})
    }
    m.dirty[key] = newEntry(value)
    m.mu.Unlock()
    return previous, loaded
}

func (m *Map) dirtyLocked() {
    if m.dirty != nil {
        return
    }
    // read map全量复制到dirty
    read := m.loadReadOnly()
    m.dirty = make(map[any]*entry, len(read.m))
    for k, e := range read.m {
        if !e.tryExpungeLocked() {
            m.dirty[k] = e
        }
    }
}

import (
    "fmt"
    "runtime"
    "testing"
    "time"
)

// Test1kGCDuration 测试小规模数据gc时长
func Test1kGCDuration(t *testing.T) {
    size := 1000
    m := GenerateStringMap(size)
    runtime.GC()
    gcCost := timeGC()
    t.Logf("size %d GC duration: %v\n", size, gcCost)
    _ = m["1"]
}

// 测试大规模数据gc时长
func Test500wGCDuration(t *testing.T) {
    size := 5000000
    m := GenerateStringMap(size)
    runtime.GC()
    gcCost := timeGC()
    t.Logf("size %d GC duration: %v\n", size, gcCost)
    _ = m["1"]
}
func GenerateStringMap(size int) map[string]string {
    // 在这里执行一些可能会触发GC的操作，例如创建大量对象等
    // 以下示例创建一个较大的map并填充数据
    m := make(map[string]string)
    for i := 0; i < size; i++ {
        key := fmt.Sprintf("key_%d", i)
        value := fmt.Sprintf("val_%d", i)
        m[key] = value

    }
    return m
}

func timeGC() time.Duration {
    // 记录GC开始时间
    gcStartTime := time.Now()
    // 手动触发GC，以便更准确地测量此次操作相关的GC时长
    runtime.GC()

    // 计算总的GC时长
    gcCost := time.Since(gcStartTime)
    return gcCost
}

// 字符串数据结构
type stringStruct struct {
    str unsafe.Pointer //指针类型，指向字节数组
    len int
}

// 测试key-value非指针类型,int的gc开销
func Test500wIntGCDuration(t *testing.T) {
    size := 5000000
    m := GenerateIntMap(size)
    runtime.GC()
    gcCost := timeGC()
    t.Logf("size %d GC duration: %v\n", size, gcCost)
    _ = m[1]
}
func GenerateIntMap(size int) map[int]int {
    // 在这里执行一些可能会触发GC的操作，例如创建大量对象等
    // 以下示例创建一个较大的map并填充数据
    m := make(map[int]int)
    for i := 0; i < size; i++ {
        m[i] = i

    }
    return m
}

func TestSmallStruct(t *testing.T) {
    type SmallStruct struct {
        data [128]byte
    }
    m := make(map[int]SmallStruct)
    size := 5000000
    for i := 0; i < size; i++ {
        m[i] = SmallStruct{}
    }
    runtime.GC()
    gcCost := timeGC()
    t.Logf("size %d GC duration: %v\n", size, gcCost)
    _ = m[1]
}
func TestBigStruct(t *testing.T) {
    type BigStruct struct {
        data [129]byte
    }
    m := make(map[int]BigStruct)
    size := 5000000
    for i := 0; i < size; i++ {
        m[i] = BigStruct{}
    }
    runtime.GC()
    gcCost := timeGC()
    t.Logf("size %d GC duration: %v\n", size, gcCost)
    _ = m[1]
}

import (
     "fmt""context""github.com/allegro/bigcache/v3"
)

cache, _ := bigcache.New(context.Background(), bigcache.DefaultConfig(10 * time.Minute))

cache.Set("my-unique-key", []byte("value"))

entry, _ := cache.Get("my-unique-key")
fmt.Println(string(entry))