Cara menggunakan Golang dan memcache untuk melaksanakan caching konkurensi tinggi.

Dengan perkembangan pesat aplikasi web, keselarasan tinggi telah menjadi masalah yang semakin biasa. Caching ialah teknologi penting untuk pembangun untuk mengekalkan prestasi aplikasi dan responsif. Dalam artikel ini, kami akan memperkenalkan cara menggunakan Golang dan memcache untuk melaksanakan caching konkurensi tinggi.

Apakah itu memcache?

Memcache ialah sistem cache memori teragih berprestasi tinggi, selalunya digunakan untuk cache data dalam aplikasi web, seperti hasil pertanyaan pangkalan data, respons API luaran, dsb. Disebabkan prestasi dan kebolehskalaannya yang tinggi, memcache digunakan secara meluas dalam aplikasi web yang melibatkan sejumlah besar operasi baca.

Cara Memcache berfungsi

Memcache berfungsi terutamanya dalam memori, dan ruang cachenya diperuntukkan oleh berbilang mesin Ia biasanya digunakan untuk menyimpan pelbagai data, seperti hasil pertanyaan pangkalan data, respons API, dsb . Setiap entri cache terdiri daripada kunci dan nilai, di mana kunci mengenal pasti data dan nilai boleh daripada sebarang jenis data.

Apabila aplikasi perlu membaca data, ia akan meminta data daripada pelayan memcache terlebih dahulu. Jika pelayan telah mencache data, ia segera mengembalikan data kepada aplikasi. Jika pelayan tidak menyimpan cache data, aplikasi akan menanyakan data daripada pangkalan data atau sumber lain dan menyimpannya dalam memcache untuk kegunaan masa hadapan. Dengan cara ini, semua permintaan seterusnya boleh mendapatkan data terus daripada cache tanpa perlu menanyakannya semula daripada pangkalan data atau sumber lain.

Menggunakan Golang dan memcache

Menggunakan memcache di Golang adalah sangat mudah. Anda boleh menggunakan perpustakaan memcache untuk menyambung terus ke pelayan memcache dan menggunakan API mudah untuk operasi baca dan tulis. Berikut ialah contoh menggunakan Golang dan memcache:

package main

import (
    "log"
    "net"
    "time"

    "github.com/bradfitz/gomemcache/memcache"
)

func main() {
    // 连接到memcache服务器
    mc := memcache.New("localhost:11211")

    // 在缓存中设置值
    err := mc.Set(&memcache.Item{Key: "mykey", Value: []byte("myvalue"), Expiration: 60})
    if err != nil {
        log.Fatalf("Error setting value: %v", err)
    }

    // 从缓存中获取值
    item, err := mc.Get("mykey")
    if err == memcache.ErrCacheMiss {
        log.Printf("Key not found in cache")
    } else if err != nil {
        log.Fatalf("Error getting value: %v", err)
    } else {
        log.Printf("Value: %s", item.Value)
    }

    // 在缓存中删除值
    err = mc.Delete("mykey")
    if err != nil {
        log.Fatalf("Error deleting value: %v", err)
    }
}

Kod contoh mula-mula bersambung ke pelayan memcache dan kemudian menyimpan kunci "mykey" dan nilai "myvalue" dalam cache dan menetapkan masa penyimpanannya kepada 60 Saat . Seterusnya, ia mendapat nilai daripada cache dan mencetaknya. Akhirnya, ia mengalih keluar nilai dari cache.

Menggunakan Golang dan memcache untuk mencapai caching concurrency tinggi

Untuk mencapai caching concurrency tinggi, kita boleh menggunakan fungsi CAS (Compare and Swap) Golang goroutine dan memcache. CAS ialah operasi atom yang membolehkan kemas kini cache tanpa menyebabkan keadaan perlumbaan.

Dalam kod contoh berikut, kami menggunakan goroutine dan CAS untuk mencapai kemas kini cache berprestasi tinggi:

package main

import (
    "log"
    "net"
    "sync"
    "time"

    "github.com/bradfitz/gomemcache/memcache"
)

func main() {
    // 连接到memcache服务器
    mc := memcache.New("localhost:11211")

    // 初始化缓存
    err := initCache(mc)
    if err != nil {
        log.Fatalf("Error initializing cache: %v", err)
    }

    var wg sync.WaitGroup

    // 并发查询
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            log.Printf("Fetching key %d", i)
            item, err := mc.Get("mykey")
            if err == memcache.ErrCacheMiss {
                log.Printf("Key not found in cache")
            } else if err != nil {
                log.Fatalf("Error getting value: %v", err)
            } else {
                log.Printf("Value: %s", item.Value)
            }
        }(i)
    }

    // 等待所有的查询结束
    wg.Wait()

    log.Printf("Done")
}

func initCache(mc *memcache.Client) error {
    // 为每个键值对设置一个版本号
    const key = "mykey"
    const maxVersion = 10
    for i := 0; i < maxVersion; i++ {
        item := &memcache.Item{
            Key:        key,
            Value:      []byte("myvalue"),
            Expiration: 60,
            Flags:      uint32(i), // 版本号
        }
        if err := mc.Set(item); err != nil {
            return err
        }
    }

    // 设置缓存版本号
    item := &memcache.Item{
        Key:        key,
        Value:      []byte("myvalue"),
        Expiration: 0,
        Flags:      uint32(maxVersion),
    }
    return mc.Set(item)
}

Kod sampel mula-mula bersambung ke pelayan memcache dan memulakan cache, untuk setiap nilai kunci Tetapkan nombor versi untuk kedua-duanya. Selepas itu, ia menggunakan goroutine untuk mengambil setiap pasangan nilai kunci daripada cache secara serentak. Sebelum mendapat setiap nilai, ia terlebih dahulu mendapat nombor versi semasa dan menyimpannya dalam pembolehubah. Ia kemudian mengambil nilai daripada cache dan menyemak sama ada nombor versi adalah sama seperti sebelum mengambilnya. Jika ia adalah sama, bermakna cache belum tamat tempoh dan nilainya boleh digunakan secara langsung. Jika tidak, ia akan mengambil semula nilai daripada pangkalan data atau sumber lain dan menyimpannya dalam cache. Dengan cara ini, walaupun berbilang permintaan menanyakan pasangan nilai kunci yang sama pada masa yang sama, ia dijamin bahawa hanya satu permintaan akan memperoleh nilai dari luar, manakala permintaan lain akan memperoleh nilai terus daripada cache untuk meningkatkan prestasi.

Kesimpulan

Dalam artikel ini, kami memperkenalkan cara menggunakan Golang dan memcache untuk melaksanakan caching konkurensi tinggi. Kami juga menunjukkan kepada anda cara menggunakan goroutine dan fungsi CAS memcache untuk mencapai kemas kini cache berprestasi tinggi. Jika anda menulis aplikasi web yang sangat serentak, menggunakan memcache ialah cara yang berkesan untuk meningkatkan prestasi aplikasi. Memcache amat diperlukan semasa menulis aplikasi web di Golang.

Atas ialah kandungan terperinci Cara menggunakan Golang dan memcache untuk melaksanakan caching konkurensi tinggi.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!