Bagaimana untuk menggunakan caching dalam Go?

Caching ialah teknologi yang biasa digunakan dalam sains komputer yang boleh meningkatkan prestasi sistem dan kelajuan tindak balas dengan berkesan. Dalam bahasa Go, terdapat banyak pelaksanaan cache yang berbeza, seperti penyegerakan.Peta, peta, Cache LRU, Redis, dsb. Untuk senario dan keperluan penggunaan yang berbeza, kita perlu memilih penyelesaian caching yang berbeza. Dalam artikel ini, kami akan membincangkan pengetahuan dan teknik yang berkaitan tentang cara menggunakan caching dalam Go.

Pelaksanaan cache dalam bahasa Go

Dalam Go, kita boleh menggunakan peta untuk melaksanakan cache asas. Sebagai contoh, kita boleh mentakrifkan peta untuk memetakan URL kepada tatasusunan bait kandungan responsnya, dan kemudian apabila memproses permintaan HTTP, semak sama ada respons yang sepadan dengan URL itu wujud dalam cache Jika wujud, kembalikan respons tersebut kandungan dalam cache, sebaliknya daripada Dapatkan data respons daripada sumber data asal dan tambahkannya pada cache. Berikut ialah contoh pelaksanaan:

package main

import (
    "fmt"
    "sync"
)

var cache = struct {
    sync.RWMutex
    data map[string][]byte
}{data: make(map[string][]byte)}


func main() {

    url := "https://www.example.com"
    if res, ok := get(url); ok {
        fmt.Println("cache hit")
        fmt.Println(string(res))
    } else {
        fmt.Println("cache miss")

        // fetch response from url
        res := fetchContent(url)
        set(url, res)
        fmt.Println(string(res))
    }
}

func get(key string) ([]byte, bool) {
    cache.RLock()
    defer cache.RUnlock()
    if res, ok := cache.data[key]; ok {
        return res, true
    }
    return nil, false
}

func set(key string, value []byte) {
    cache.Lock()
    defer cache.Unlock()
    cache.data[key] = value
}

func fetchContent(url string) []byte {
    // fetch content from url
    // ...
}

Dalam contoh kod di atas, kami mula-mula menentukan pembolehubah global bernama cache, yang mempunyai kunci baca-tulis dan peta untuk menyimpan hubungan antara URL dan kandungan tindak balasnya hubungan pemetaan. Seterusnya, apabila memproses permintaan HTTP, kami menggunakan fungsi get untuk mendapatkan respons daripada cache, dan mengembalikannya secara langsung jika ia wujud. Jika tidak, kami menggunakan fungsi fetchContent untuk mendapatkan data respons daripada sumber data asal dan menambahnya cache.

Selain menggunakan peta, bahasa Go juga menyediakan beberapa pelaksanaan cache lain, seperti sync.Map dan LRU Cache.

sync.Map ialah peta selamat benang yang boleh melakukan operasi baca dan tulis serentak antara berbilang goroutin tanpa mengunci. Menggunakan sync.Map untuk melaksanakan caching boleh meningkatkan prestasi concurrency sistem. Berikut ialah contoh pelaksanaan:

package main

import (
    "fmt"
    "sync"
)

func main() {
    m := sync.Map{}
    m.Store("key1", "value1")
    m.Store("key2", "value2")

    if res, ok := m.Load("key1"); ok {
        fmt.Println(res)
    }
    m.Range(func(k, v interface{}) bool {
        fmt.Printf("%v : %v
", k, v)
        return true
    })
}

Dalam contoh kod di atas, kami menyimpan data dalam peta dengan memanggil kaedah Simpan penyegerakan.Peta dan dapatkan data daripada peta menggunakan kaedah Muat. Selain itu, kita juga boleh menggunakan kaedah Julat untuk melaksanakan fungsi merentasi peta.

LRU Cache ialah strategi caching biasa yang menggunakan algoritma yang paling kurang digunakan baru-baru ini (Paling Kurang Digunakan) untuk menggantikan data yang paling kurang digunakan baru-baru ini daripada cache apabila ruang cache penuh. Dalam bahasa Go, anda boleh menggunakan pakej golang-lru untuk melaksanakan Cache LRU. Berikut ialah contoh pelaksanaan:

package main

import (
    "fmt"
    "github.com/hashicorp/golang-lru"
)

func main() {
    cache, _ := lru.New(128)
    cache.Add("key1", "value1")
    cache.Add("key2", "value2")

    if res, ok := cache.Get("key1"); ok {
        fmt.Println(res)
    }
    cache.Remove("key2")
    fmt.Println(cache.Len())
}

Dalam contoh kod di atas, kami mula-mula mencipta Cache LRU, menambah data pada cache dengan memanggil kaedah Tambah, dapatkan data daripada cache menggunakan kaedah Dapatkan, dan gunakan kaedah Alih Keluar Padam data daripada Cache LRU.

Cara mereka bentuk sistem caching yang cekap

Untuk senario dan keperluan yang berbeza, kita selalunya perlu memilih strategi caching yang berbeza. Walau bagaimanapun, tidak kira apa strategi caching yang diguna pakai, kita perlu mempertimbangkan cara mereka bentuk sistem caching yang cekap.

Berikut ialah beberapa petua untuk mereka bentuk sistem caching yang cekap:

1. Tetapkan saiz cache yang sesuai

Saiz cache hendaklah berdasarkan memori sistem dan corak capaian data untuk ditetapkan. Jika cache terlalu besar, memori sistem akan menjadi ketat dan prestasi sistem akan berkurangan Jika cache terlalu kecil, sumber sistem tidak dapat digunakan sepenuhnya dan cache yang mencukupi tidak dapat disediakan.

2. Tetapkan masa tamat tempoh cache yang sesuai

Menetapkan masa tamat tempoh cache yang sesuai boleh menghalang data cache daripada terlalu lama dan memastikan sifat masa nyata data. Masa tamat cache hendaklah ditetapkan berdasarkan ciri-ciri data dan corak capaian.

3. Gunakan cache berbilang peringkat

Untuk data yang tidak diakses dengan kerap, anda boleh menggunakan cache storan cakera atau rangkaian yang lebih besar untuk data yang diakses dengan lebih kerap, Untuk data, cache memori yang lebih kecil boleh digunakan. Melalui caching berperingkat, prestasi dan kebolehskalaan sistem boleh dipertingkatkan.

4. Penembusan cache

Penembusan cache bermakna data yang diminta tidak wujud dalam cache dan data yang diminta tidak wujud dalam sumber data. Untuk mengelakkan penembusan cache, anda boleh menambah bendera Boolean untuk menunjukkan sama ada data wujud apabila cache tamat tempoh. Apabila data pertanyaan tidak wujud, data kosong dikembalikan dan bit bendera data ditetapkan kepada palsu Pertanyaan seterusnya akan berdasarkan bit bendera untuk mengelakkan pertanyaan berulang.

5. Cache avalanche

Cache avalanche bermakna sejumlah besar data cache gagal pada masa yang sama, menyebabkan sejumlah besar permintaan ditekan pada bahagian belakang sistem, menyebabkan sistem ranap. Untuk mengelakkan masalah salji cache, anda boleh menggunakan rawak masa tamat cache untuk mengedarkan, atau membahagikan masa tamat cache kepada beberapa tempoh masa, dan masa tamat tempoh dalam tempoh masa yang berbeza adalah rawak untuk mengelakkan sejumlah besar cache kegagalan pada masa yang sama, menyebabkan beban sistem yang berlebihan.

Ringkasan

Dalam bahasa Go, menggunakan cache boleh meningkatkan prestasi sistem dan kelajuan tindak balas dengan berkesan. Kita boleh memilih penyelesaian pelaksanaan cache yang berbeza, seperti peta, penyegerakan.Peta, Cache LRU, Redis, dsb. Pada masa yang sama, apabila mereka bentuk sistem cache yang cekap, adalah perlu untuk memilih strategi cache yang sesuai berdasarkan keperluan dan senario tertentu, dan mempertimbangkan isu seperti saiz cache, masa tamat tempoh cache, cache berbilang peringkat, penembusan cache, runtuhan cache. , dsb.

Atas ialah kandungan terperinci Bagaimana untuk menggunakan caching dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!