Teknik praktikal untuk menggunakan cache untuk mengendalikan permintaan besar-besaran di Golang.

Petua praktikal untuk menggunakan cache untuk mengendalikan permintaan besar-besaran di Golang

Dengan perkembangan Internet, permintaan besar-besaran telah menjadi masalah yang tidak dapat dielakkan untuk aplikasi web moden. Permintaan ini perlu dijawab dengan cekap, jika tidak, pengalaman pengguna akan terjejas dengan serius. Di Golang, kami boleh menggunakan caching untuk meningkatkan kelajuan tindak balas permintaan untuk menangani cabaran permintaan besar-besaran dengan lebih baik.

Artikel ini akan memperkenalkan kemahiran praktikal menggunakan cache untuk mengendalikan permintaan besar-besaran di Golang, termasuk struktur data cache, kaedah penjanaan cache, kemas kini dan pemadaman cache, kapasiti cache dan keselamatan konkurensi, dsb.

Struktur data cache

Struktur data cache di Golang umumnya dilaksanakan menggunakan peta. Ini kerana peta di Golang mempunyai kecekapan carian yang sangat tinggi dan juga boleh menyokong penambahan dan pemadaman unsur yang dinamik.

Sebagai contoh, kita boleh mentakrifkan peta untuk menyimpan maklumat pengguna:

type User struct {
    Name string
    Age int
}

var usersCache = make(map[int]*User)

Antaranya, usersCache ialah peta yang digunakan untuk menyimpan maklumat pengguna Nilai utama ialah ID pengguna dan nilainya struktur Pengguna.

Kaedah penjanaan cache

Kaedah penjanaan cache boleh dibahagikan kepada dua kategori: penjanaan statik dan penjanaan dinamik.

Penjanaan statik bermaksud menjana cache apabila aplikasi dimulakan Kaedah ini sesuai untuk situasi di mana data cache tidak kerap berubah. Kita boleh membaca data daripada pangkalan data atau sumber data lain semasa pemulaan program dan cache ia.

Sebagai contoh, kita boleh membaca maklumat pengguna daripada pangkalan data apabila program bermula dan cache ia:

func init() {
    // 从数据库中读取用户信息
    rows, err := db.Query("SELECT * FROM users")
    if err != nil {
        log.Fatal(err)
    }
    defer rows.Close()

    // 将用户信息缓存起来
    for rows.Next() {
        var user User
        if err := rows.Scan(&user.ID, &user.Name, &user.Age); err != nil {
            log.Fatal(err)
        }
        usersCache[user.ID] = &user
    }
}

Penjanaan dinamik bermakna apabila tiada data dalam cache, ia akan dijana daripada data mengikut keperluan Cache dijana secara dinamik daripada sumber.

Sebagai contoh, kami boleh mentakrifkan fungsi GetUser untuk mendapatkan maklumat pengguna, membaca data daripada sumber data dan menjana cache seperti yang diperlukan:

func GetUser(id int) (*User, error) {
    // 先从缓存中查找用户信息
    user, ok := usersCache[id]
    if ok {
        return user, nil
    }

    // 如果缓存中不存在，则从数据库中读取用户信息
    var user User
    err := db.QueryRow("SELECT * FROM users WHERE id=?", id).Scan(&user.ID, &user.Name, &user.Age)
    if err != nil {
        return nil, err
    }

    // 将用户信息缓存起来
    usersCache[id] = &user

    return &user, nil
}

Kemas kini dan pemadaman cache

Apabila data dalam sumber data berubah, data dalam cache juga perlu dikemas kini dan dipadamkan dengan sewajarnya.

Sebagai contoh, apabila maklumat pengguna berubah, kami perlu mengemas kini maklumat pengguna dalam cache:

func UpdateUser(id int, name string, age int) error {
    // 更新数据库中的用户信息
    _, err := db.Exec("UPDATE users SET name=?, age=? WHERE id=?", name, age, id)
    if err != nil {
        return err
    }

    // 更新缓存中的用户信息
    user, ok := usersCache[id]
    if ok {
        user.Name = name
        user.Age = age
    }

    return nil
}

Apabila pengguna log keluar, kami perlu memadam maklumat pengguna daripada cache:

func DeleteUser(id int) error {
    // 从数据库中删除用户信息
    _, err := db.Exec("DELETE FROM users WHERE id=?", id)
    if err != nil {
        return err
    }

    // 从缓存中删除用户信息
    delete(usersCache, id)

    return nil
}

Kapasiti cache dan keselamatan serentak

Kapasiti cache merupakan isu yang sangat penting Jika cache tidak cukup besar, ia boleh menyebabkan data cache dikitar semula dan digunakan semula dengan kerap, menjejaskan sistem. prestasi. Jika cache terlalu besar, ia boleh menyebabkan masalah seperti limpahan memori dan ranap sistem. Oleh itu, kapasiti cache perlu dipertimbangkan sepenuhnya semasa mereka bentuk cache.

Selain itu, memandangkan berbilang goroutine boleh mengakses cache pada masa yang sama, keselamatan serentak cache juga merupakan isu yang memerlukan perhatian. Kami boleh menggunakan Mutex atau RWMutex yang disediakan oleh pakej penyegerakan untuk memastikan keselamatan penyelarasan cache.

Sebagai contoh, kami boleh menggunakan RWMutex untuk memastikan keselamatan serentak fungsi GetUser:

type UsersCache struct {
    cache map[int]*User
    mu sync.RWMutex
}

var usersCache = UsersCache{cache: make(map[int]*User)}

func GetUser(id int) (*User, error) {
    usersCache.mu.RLock()
    user, ok := usersCache.cache[id]
    usersCache.mu.RUnlock()

    if ok {
        return user, nil
    }

    usersCache.mu.Lock()
    defer usersCache.mu.Unlock()

    // 二次检查
    user, ok = usersCache.cache[id]
    if !ok {
        // 如果缓存中不存在，则从数据库中读取用户信息
        var user User
        err := db.QueryRow("SELECT * FROM users WHERE id=?", id).Scan(&user.ID, &user.Name, &user.Age)
        if err != nil {
            return nil, err
        }

        // 将用户信息缓存起来
        usersCache.cache[id] = &user

        return &user, nil
    }

    return user, nil
}

Dalam contoh di atas, kami menggunakan RWMutex untuk memastikan keselamatan serentak cache dan menggunakan penguncian berganda teknologi Untuk mengelakkan penciptaan pendua cache.

Ringkasan

Artikel ini memperkenalkan kemahiran praktikal menggunakan cache untuk mengendalikan permintaan besar-besaran di Golang, termasuk struktur data cache, kaedah penjanaan cache, kemas kini dan pemadaman cache, kapasiti cache dan konkurensi Keselamatan dan lain-lain aspek. Dengan menggunakan caching secara fleksibel, kami dapat mengatasi cabaran permintaan besar-besaran dengan lebih baik dan meningkatkan prestasi dan kestabilan sistem.

Atas ialah kandungan terperinci Teknik praktikal untuk menggunakan cache untuk mengendalikan permintaan besar-besaran di Golang.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!