Laksanakan strategi penghapusan cache berasaskan keutamaan di Golang.

Dengan perkembangan berterusan teknologi Internet, caching telah menjadi salah satu teknologi terasnya. Caching boleh meningkatkan kelajuan akses pengguna dan mengurangkan tekanan beban pada pelayan, dan penghapusan cache adalah bahagian penting dalam sistem caching. Dalam artikel ini, kami akan memperkenalkan cara melaksanakan strategi pengusiran cache berasaskan keutamaan di Golang.

1. Apakah itu strategi penghapusan cache

Penghapusan cache bermakna apabila cache penuh, beberapa data cache perlu dikosongkan mengikut peraturan tertentu untuk menyimpan data baharu dalam cache. Strategi penghapusan cache yang berbeza mempunyai peraturan yang berbeza, seperti FIFO (pertama masuk dahulu), LRU (paling kurang digunakan baru-baru ini), LFU (paling kurang digunakan baru-baru ini), algoritma rawak, dsb.

2. Pelaksanaan di Golang

Peta di Golang boleh digunakan dengan mudah untuk melaksanakan caching. Berikut ialah pengenalan ringkas tentang cara menggunakan peta untuk melaksanakan strategi penghapusan cache di Golang.

1. FIFO

FIFO ialah strategi penyingkiran cache yang paling mudah, yang mengosongkan data satu demi satu mengikut urutan ia memasuki cache. Di Golang, kita boleh menggunakan peta dan senarai untuk melaksanakan FIFO. Peta digunakan untuk menyimpan data cache, dan senarai digunakan untuk menyimpan susunan data yang dimasukkan. Apabila cache penuh, kami mencari data yang dimasukkan pertama melalui senarai dan mengosongkannya daripada peta dan senarai.

2. LRU

LRU ialah strategi pengusiran cache berdasarkan prinsip yang paling kurang digunakan baru-baru ini dan secara amnya dianggap sebagai strategi yang agak unggul. Di Golang, kami juga boleh menggunakan peta dan senarai berganda (atau senarai) untuk melaksanakan LRU. Peta digunakan untuk menyimpan data cache dan senarai terpaut dua kali digunakan untuk mengekalkan susunan data cache digunakan. Apabila data cache digunakan, kami mengalihkannya ke kepala senarai terpaut. Apabila cache penuh, kami mencari data tertua yang tidak digunakan melalui ekor senarai terpaut dan mengosongkannya daripada peta dan senarai terpaut.

3. LFU

LFU ialah strategi penyingkiran cache berdasarkan prinsip yang paling kurang digunakan, yang mungkin lebih sesuai daripada LRU dalam sesetengah senario. Di Golang, kita juga boleh menggunakan peta dan timbunan untuk melaksanakan LFU. Peta digunakan untuk menyimpan data cache, dan timbunan digunakan untuk mengekalkan data cache yang diisih mengikut penggunaan. Apabila data cache tertentu digunakan, kami melaraskan (atau memasukkan semula) nodnya dalam timbunan ke lokasi kiraan penggunaan baharu. Apabila cache penuh, kami mencari data yang paling kurang digunakan daripada timbunan dan mengosongkannya daripada peta dan timbunan.

3. Strategi penghapusan cache berasaskan keutamaan

Selain daripada strategi penghapusan cache biasa yang diperkenalkan di atas, strategi penghapusan cache juga boleh disesuaikan mengikut senario perniagaan. Sebagai contoh, dalam beberapa senario, kita perlu memutuskan data mana yang harus disimpan dahulu berdasarkan keutamaan tertentu. Jadi bagaimana untuk melaksanakannya di Golang?

Strategi pengusiran cache berasaskan keutamaan boleh dilaksanakan dengan menggabungkan peta dan timbunan. Peta digunakan untuk menyimpan data cache, dan timbunan digunakan untuk mengekalkan data cache diisih mengikut keutamaan. Untuk melaksanakan strategi penghapusan cache berasaskan keutamaan, kita perlu menentukan keutamaan untuk setiap data cache. Ini boleh dicapai dengan menambahkan atribut keutamaan pada data cache, atau dengan merangkumnya ke dalam struktur dan menambah medan keutamaan.

Berikut ialah contoh kod:

type CacheItem struct {
    Key       string
    Value     interface{}
    Priority  int64 // 优先级
    Timestamp int64
}

type PriorityQueue []*CacheItem

func (pq PriorityQueue) Len() int { return len(pq) }

func (pq PriorityQueue) Less(i, j int) bool {
    return pq[i].Priority > pq[j].Priority
}

func (pq PriorityQueue) Swap(i, j int) {
    pq[i], pq[j] = pq[j], pq[i]
}

func (pq *PriorityQueue) Push(x interface{}) {
    item := x.(*CacheItem)
    *pq = append(*pq, item)
}

func (pq *PriorityQueue) Pop() interface{} {
    old := *pq
    n := len(old)
    item := old[n-1]
    *pq = old[0 : n-1]
    return item
}

type Cache struct {
    data     map[string]*CacheItem
    priority *PriorityQueue
    cap      int
    expire   time.Duration // 过期时间
}

Dalam kod di atas, kami mentakrifkan CacheItem dan PriorityQueue. CacheItem mewakili item data dalam cache, yang merangkumi empat atribut: Kunci, Nilai, Keutamaan dan Cap Masa. PriorityQueue ialah struktur yang melaksanakan heap.Antara muka antara muka dan digunakan untuk mengekalkan data cache yang diisih mengikut keutamaan.

Seterusnya, kami mentakrifkan struktur Cache, yang mengandungi beberapa atribut seperti data, keutamaan, had dan tamat tempoh. data digunakan untuk menyimpan data cache, keutamaan digunakan untuk mengekalkan keutamaan data, topi mewakili kapasiti cache, dan tamat tempoh mewakili masa tamat data cache.

Berikut ialah contoh kod untuk menghapuskan data cache berdasarkan keutamaan:

func (cache *Cache) Set(key string, value interface{}, priority int64) {
    item := &CacheItem{
        Key:      key,
        Value:    value,
        Priority: priority,
        Timestamp: time.Now().UnixNano(),
    }
    cache.data[key] = item
    heap.Push(cache.priority, item)

    // 进行缓存淘汰
    if len(cache.data) > cache.cap {
        for {
            item := heap.Pop(cache.priority).(*CacheItem)
            if _, ok := cache.data[item.Key]; ok {
                delete(cache.data, item.Key)
                break
            }
        }
    }
}

func (cache *Cache) Get(key string) interface{} {
    item, ok := cache.data[key]
    if !ok {
        return nil
    }
    // 更新优先级
    item.Priority += 1
    item.Timestamp = time.Now().UnixNano()
    heap.Fix(cache.priority, item.Index)
    return item.Value
}

Dalam kaedah Set, kami memasukkan data cache ke dalam peta dan keutamaan semasa melakukan penghapusan cache. Apabila cache penuh, kami mencari data keutamaan terendah melalui heap.Pop dan kosongkannya daripada peta dan keutamaan.

Dalam kaedah Dapatkan, kami mencari data melalui peta, meningkatkan keutamaannya sebanyak 1 dan mengemas kini Cap Waktunya pada masa yang sama. Kemudian, kami melaraskan kedudukannya dalam keutamaan melalui heap.Fix.

4. Ringkasan

Artikel ini memperkenalkan pelaksanaan tiga strategi penghapusan cache biasa (FIFO, LRU, LFU) di Golang, serta kod sampel strategi penghapusan cache berasaskan keutamaan . Dalam senario sebenar, strategi caching yang berbeza sesuai untuk senario aplikasi yang berbeza dan perlu dipilih mengikut keperluan perniagaan. Pada masa yang sama, beberapa butiran harus dipertimbangkan apabila menggunakan cache, seperti kapasiti cache dan masa tamat tempoh.

Atas ialah kandungan terperinci Laksanakan strategi penghapusan cache berasaskan keutamaan di Golang.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!