Cara menggunakan bahasa Go dan Redis untuk kawalan aliran

Cara menggunakan bahasa Go dan Redis untuk kawalan aliran

Pengenalan
Dalam aplikasi rangkaian konkurensi tinggi, kawalan aliran ialah pautan yang sangat penting. Untuk memastikan kestabilan dan kebolehpercayaan sistem, kami perlu mengehadkan dan mengurus trafik. Artikel ini akan memperkenalkan cara menggunakan bahasa Go dan Redis untuk melaksanakan kawalan aliran dan memberikan contoh kod khusus.

Latar Belakang
Dalam sistem teragih, kawalan aliran adalah salah satu cara penting untuk memastikan operasi normal sistem. Apabila sistem menghadapi permintaan serentak yang tinggi, trafik yang berlebihan boleh menyebabkan sistem ranap atau bertindak balas dengan perlahan. Oleh itu, kita perlu mengehadkan trafik untuk mengelakkan sistem daripada lebih muatan. Redis ialah pangkalan data dalam memori berprestasi tinggi yang menyediakan struktur data yang kaya dan arahan untuk memudahkan kawalan aliran.

Reka Bentuk Projek
Reka bentuk penyelesaian kami adalah seperti berikut:

1. Gunakan struktur data kaunter Redis untuk merekodkan bilangan permintaan bagi setiap pengguna.
2. Gunakan Set Isih untuk menyimpan cap waktu permintaan pengguna untuk pengiraan tetingkap masa berikutnya.
3. Gunakan fungsi transaksi Redis untuk memastikan atomicity dan konsistensi operasi.
4. Gunakan Goroutine untuk pemprosesan serentak.

Pelaksanaan khusus
Kami mengandaikan bahawa pengguna hanya boleh menghantar 100 permintaan dalam masa 60 saat. Kita boleh menggunakan struktur data kaunter Redis untuk mencapai sekatan ini. Berikut ialah contoh kod:

package main

import (
    "fmt"
    "strconv"
    "sync"
    "time"

    "github.com/go-redis/redis"
)

var (
    wg sync.WaitGroup
    rdb *redis.Client
)

func main() {
    rdb = redis.NewClient(&redis.Options{
        Addr:     "localhost:6379", // Redis地址
        Password: "",               // Redis密码
        DB:       0,                // Redis数据库
    })

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go sendRequest(i)
    }

    wg.Wait()
}

func sendRequest(userID int) {
    defer wg.Done()

    // 检查用户请求数是否超过限制
    count, err := rdb.Incr(strconv.Itoa(userID)).Result()
    if err != nil {
        fmt.Println("Redis error:", err)
        return
    }

    if count > 100 {
        fmt.Println("Request limit exceeded for user", userID)
        return
    }

    // 获取当前时间戳
    now := time.Now().Unix()

    // 将当前时间戳添加到有序集合中
    _, err = rdb.ZAdd("timestamps", redis.Z{
        Score:  float64(now),
        Member: strconv.Itoa(userID),
    }).Result()
    if err != nil {
        fmt.Println("Redis error:", err)
        return
    }

    // 移除60秒前的时间戳
    _, err = rdb.ZRemRangeByScore("timestamps", "0", strconv.FormatInt(now-60, 10)).Result()
    if err != nil {
        fmt.Println("Redis error:", err)
        return
    }

    fmt.Println("Request sent by user", userID)
}

Penjelasan dan hubungi

• Mula-mula, sambung ke pangkalan data Redis dengan mencipta klien Redis.
• Kemudian, gunakan gelung untuk mencipta 100 coroutine untuk menghantar permintaan. Setiap coroutine mewakili pengguna.
• Dalam fungsi sendRequest yang menghantar permintaan, mula-mula gunakan perintah INCR untuk menambah bilangan permintaan pengguna dan semak sama ada had telah melebihi. sendRequest中，首先使用INCR命令递增用户的请求数，并检查是否超过了限制。
• 然后，获取当前时间戳，并将其添加到有序集合中。
• 最后，使用ZRemRangeByScore
Kemudian, dapatkan cap masa semasa dan tambahkannya pada set yang diisih.

Akhir sekali, gunakan perintah ZRemRangeByScore untuk mengalih keluar cap masa yang telah tamat tempoh.

Kesimpulan

• Bahan rujukan:
• Dokumentasi rasmi Redis: https://redis.io/

Atas ialah kandungan terperinci Cara menggunakan bahasa Go dan Redis untuk kawalan aliran. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!