Prinsip pelaksanaan cara cache dan kunci berfungsi bersama di Golang.

Prinsip cara cache dan kunci berfungsi bersama di Golang

Dalam pengaturcaraan serentak, cache dan kunci ialah dua konsep biasa. Ia digunakan untuk mengoptimumkan prestasi program dan mengekalkan konsistensi data masing-masing. Di Golang, caching dan kunci biasanya digunakan bersama untuk melaksanakan beberapa senario konkurensi tinggi. Artikel ini akan memperkenalkan prinsip pelaksanaan cara cache dan kunci berfungsi bersama di Golang.

1. Pelaksanaan cache di Golang

Cache ialah mekanisme untuk menyimpan hasil pengiraan dalam ingatan untuk mengelakkan pengiraan berulang dan mempercepatkan akses kepada data. Di Golang, pustaka standard menyediakan pakej penyegerakan, yang termasuk jenis yang dipanggil Peta, yang boleh digunakan untuk melaksanakan caching.

sync.Map ialah cache selamat benang yang menyokong akses serentak kepada cache. Di bawah ialah contoh penggunaan sync.Map untuk melaksanakan caching.

package main

import (
    "fmt"
    "sync"
)

func main() {
    var cache sync.Map

    // 设置缓存
    cache.Store("hello", "world")

    // 获取缓存
    val, ok := cache.Load("hello")
    if ok {
        fmt.Println(val)
    }
}

Dalam contoh di atas, kami mula-mula mencipta cache pembolehubah jenis penyegerakan.Peta. Kami kemudian menggunakan kaedah Kedai untuk menyimpan nilai "dunia" ke dalam cache dan mengaitkannya dengan kunci "hello". Akhir sekali, kami menggunakan kaedah Muat untuk mendapatkan semula nilai dengan kekunci "hello" daripada cache.

2. Pelaksanaan kunci di Golang

Apabila berbilang coroutine bersaing untuk mendapatkan sumber yang dikongsi, penyegerakan kunci ialah kaedah biasa. Di Golang, pustaka standard menyediakan tiga jenis kunci: sync.Mutex, sync.RWMutex dan sync.WaitGroup.

sync.Mutex ialah jenis kunci yang paling asas Ia menyediakan dua kaedah mudah: Kunci dan Buka Kunci. Apabila coroutine memanggil kaedah Kunci, jika kunci tidak diduduki oleh coroutine lain, maka ia akan memperoleh kunci. Jika kunci sudah diduduki oleh coroutine lain, kaedah Kunci akan menyekat sehingga kunci dilepaskan. Apabila coroutine memanggil kaedah Buka Kunci, ia melepaskan kunci.

sync.Mutex digunakan secara meluas untuk melaksanakan akses saling eksklusif untuk menghalang berbilang coroutine daripada mengubah suai pembolehubah yang sama pada masa yang sama. Di bawah ialah contoh menggunakan sync.Mutex untuk melaksanakan kunci.

package main

import (
    "fmt"
    "sync"
)

var counter int
var lock sync.Mutex

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            lock.Lock()
            counter++
            lock.Unlock()
            wg.Done()
        }()
    }
    wg.Wait()
    fmt.Println(counter)
}

Dalam contoh di atas, kami menentukan pembolehubah bernama pembilang dan kunci pembolehubah jenis penyegerakan.Mutex. Kemudian kita mulakan 1000 coroutine Setiap coroutine mula-mula akan memperoleh kunci, kemudian meningkatkan nilai pembilang, dan akhirnya melepaskan kunci. Disebabkan kewujudan kunci, berbilang coroutine boleh mengendalikan kaunter dengan selamat, memastikan ketekalan data.

3. Prinsip cara cache dan kunci berfungsi bersama di Golang

Apabila pembacaan dan penulisan serentak cache diperlukan, kita perlu menggunakan kunci untuk memastikan ketekalan data. Beginilah cara caching dan penguncian berfungsi bersama.

Berikut ialah contoh penggunaan penyegerakan.Mutex untuk melaksanakan caching.

package main

import (
    "fmt"
    "sync"
)

type cache struct {
    data map[string]string
    lock sync.Mutex
}

func newCache() *cache {
    return &cache{
        data: make(map[string]string),
    }
}

func (c *cache) set(key string, val string) {
    c.lock.Lock()
    defer c.lock.Unlock()
    c.data[key] = val
}

func (c *cache) get(key string) (string, bool) {
    c.lock.Lock()
    defer c.lock.Unlock()
    val, ok := c.data[key]
    return val, ok
}

func main() {
    c := newCache()
    c.set("hello", "world")
    val, ok := c.get("hello")
    if ok {
        fmt.Println(val)
    }
}

Dalam contoh di atas, kami menentukan struktur bernama cache, yang mengandungi data jenis peta dan kunci jenis Mutex. Kami menggunakan kaedah yang ditetapkan untuk menyimpan data dalam cache dan kaedah dapatkan untuk mendapatkan data daripada cache. Dalam kaedah set dan dapatkan, kami menggunakan kaedah kunci untuk memperoleh kunci dan lepaskan kunci apabila kaedah selesai pelaksanaan. Disebabkan kewujudan kunci, berbilang coroutine boleh membaca dan menulis cache dengan selamat, memastikan ketekalan data.

Ringkasnya, cache dan kunci ialah dua konsep biasa, yang digunakan untuk mengoptimumkan prestasi program dan mengekalkan konsistensi data masing-masing. Di Golang, kami boleh melaksanakan caching dan mengunci melalui jenis Peta dan jenis Mutex dalam pakej penyegerakan. Apabila membaca dan menulis serentak ke cache diperlukan, kita perlu menggunakan kunci untuk memastikan konsistensi data. Kerjasama cache dan kunci boleh meningkatkan prestasi serentak program dengan berkesan.

Atas ialah kandungan terperinci Prinsip pelaksanaan cara cache dan kunci berfungsi bersama di Golang.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!