Peta Penyegerakan boleh menyebabkan peningkatan dalam ram dan goroutine

editor php Youzi mengingatkan anda bahawa menggunakan Sync Map boleh membawa kepada peningkatan dalam RAM dan goroutine. Peta Penyegerakan ialah perpustakaan dalam bahasa Go yang digunakan untuk melaksanakan struktur data pemetaan selamat bersamaan. Walaupun ia memberikan prestasi yang cekap apabila mengendalikan bacaan dan tulis serentak, menggunakan Peta Penyegerakan boleh membawa kepada peningkatan dalam penggunaan memori dan bilangan goroutin semasa memproses data berskala besar. Oleh itu, apabila menggunakan Peta Segerak, anda perlu menimbang keseimbangan antara penggunaan dan prestasi mengikut senario perniagaan tertentu dan perlu memastikan kestabilan dan kecekapan sistem.

Kandungan soalan

Helo, ini adalah kod yang saya panggil util a collector

import (
    "context"
    "errors"
    "sync"
    "time"
)

type Collector struct {
    keyValMap *sync.Map
}

func (c *Collector) LoadOrWait(key any) (retValue any, availability int, err error) {
    value, status := c.getStatusAndValue(key)

    switch status {
    case 0:
        return nil, 0, nil
    case 1:
        return value, 1, nil
    case 2:
        ctxWithTimeout, _ := context.WithTimeout(context.Background(), 5 * time.Second)
        for {
            select {
            case <-ctxWithTimeout.Done():
                return nil, 0, errRequestTimeout
            default:
                value, resourceStatus := c.getStatusAndValue(key)
                if resourceStatus == 1 {
                    return value, 1, nil
                }
                time.Sleep(50 * time.Millisecond)
            }
        }
    }

    return nil, 0, errRequestTimeout
}

// Store ...
func (c *Collector) Store(key any, value any) {
    c.keyValMap.Store(key, value)
}

func (c *Collector) getStatusAndValue(key any) (retValue any, availability int) {
    var empty any
    result, loaded := c.keyValMap.LoadOrStore(key, empty)

    if loaded && result != empty {
        return result, 1
    }

    if loaded && result == empty {
        return empty, 2
    }

    return nil, 0
}

Jadi tujuan utiliti ini adalah untuk bertindak sebagai cache di mana nilai yang serupa dimuatkan sekali sahaja tetapi dibaca berbilang kali. Walau bagaimanapun, apabila objek pengumpul dihantar ke berbilang goroutin, saya menghadapi peningkatan penggunaan gorotin dan ram apabila berbilang goroutin cuba menggunakan cache pengumpul. Bolehkah seseorang menjelaskan jika penggunaan peta yang disegerakkan ini betul. Jika ya, apakah sebabnya bilangan goroutine/penggunaan memori yang tinggi

Penyelesaian

Sudah tentu, kerana fungsi pembatalan konteks ctxwithtimeout yang baru dibuat tidak dipanggil, anda mungkin menghadapi kebocoran memori. Untuk membetulkannya, tukar talian kepada:

ctxWithTimeout, cancelFunc := context.WithTimeout(context.Background(), requestTimeout)
defer cancelFunc()

Jadi, anda sentiasa boleh mengosongkan semua sumber yang diperuntukkan sebaik sahaja konteks tamat tempoh. Ini sepatutnya menyelesaikan kebocoran.
Mengenai penggunaan sync.map nampaknya baik bagi saya.
Jika ini menyelesaikan masalah anda atau terdapat isu lain yang perlu diselesaikan, sila beritahu saya, terima kasih!

Atas ialah kandungan terperinci Peta Penyegerakan boleh menyebabkan peningkatan dalam ram dan goroutine. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!