Cara menggunakan Golang untuk melaksanakan pengehadan semasa permintaan

Dengan peningkatan penggunaan aplikasi rangkaian moden, banyak permintaan pengguna mula membanjiri pelayan, yang menyebabkan beberapa masalah. Di satu pihak, prestasi pelayan adalah terhad dan tidak ada jaminan bahawa semua permintaan boleh diproses sebaliknya, sebilangan besar permintaan yang tiba pada masa yang sama mungkin membuat perkhidmatan tidak stabil. Pada masa ini, mengehadkan kadar permintaan telah menjadi pilihan yang tidak dapat dielakkan Berikut akan memperkenalkan cara menggunakan Golang untuk melaksanakan pengehadan semasa permintaan.

Apakah pendikitan?

Pendikit pendikit merujuk kepada mengehadkan bilangan maksimum permintaan atau trafik data yang boleh tahan oleh aplikasi, sistem atau perkhidmatan dalam tempoh masa tertentu. Pengehadan semasa boleh membantu kami mengurangkan serangan rangkaian dan mencegah penyalahgunaan lebar jalur dan penyalahgunaan sumber. Biasanya kami memanggil had ini "kawalan aliran", yang boleh mengutamakan permintaan jenis dan sumber yang berbeza dan memproses permintaan jenis dan sumber yang berbeza pada perkadaran yang berbeza.

Melaksanakan pengehadan semasa permintaan

Algoritma pengehad semasa tetingkap berasaskan tetingkap masa

Algoritma yang paling mudah dan langsung ialah algoritma pengehadan semasa berasaskan tetingkap masa. Ia menyemak sama ada jumlah bilangan permintaan yang dihantar dalam tempoh terkini melebihi ambang. Panjang tetingkap masa boleh dilaraskan mengikut ciri-ciri aplikasi untuk mencapai prestasi optimum dan kadar penggera palsu minimum.

Andaikan kita perlu mengehadkan bilangan maksimum akses sesaat kepada API Kita boleh menggunakan pakej masa di Golang untuk mengira trafik dan menggunakan saluran penimbal untuk melaksanakan baris gilir permintaan. Kodnya adalah seperti berikut:

type ApiLimiter struct {
    rate       float64 // 时间窗口内最大请求数
    capacity   int // 请求队列最大长度，即最多能有多少请求同时被处理
    requestNum int // 时间窗口内已处理请求总数
    queue      chan int // 缓冲通道，用于实现请求队列
}

func NewApiLimiter(rate float64, capacity int) *ApiLimiter {
    return &ApiLimiter{
        rate:       rate,
        capacity:   capacity,
        requestNum: 0,
        queue:      make(chan int, capacity),
    }
}
func (al *ApiLimiter) Request() bool {
    now := time.Now().UnixNano()
    maxRequestNum := int(float64(now)/float64(time.Second)*al.rate) + 1 // 统计最近一秒内应该处理的请求数量
    if maxRequestNum <= al.requestNum { // 超过最大请求数，返回false
        return false
    }
    al.queue <- 1 // 将请求压入队列
    al.requestNum += 1
    return true
}

Dalam contoh ini, kami menggunakan chan dalam Golang untuk melaksanakan baris gilir permintaan dan menggunakan pakej masa untuk mengira bilangan permintaan dalam tetingkap masa. Selepas setiap permintaan sampai ke pelayan, kami akan meletakkan permintaan ke dalam baris gilir, dan jumlah permintaan juga akan dibandingkan dengan bilangan maksimum permintaan Jika melebihi bilangan maksimum, palsu akan dikembalikan.

Algoritma Baldi Bocor

Algoritma Baldi Bocor ialah satu lagi algoritma pengehad semasa yang terkenal Pada bila-bila masa, baldi bocor mengekalkan bilangan permintaan tertentu. Apabila permintaan baharu tiba, semak dahulu sama ada bilangan permintaan yang tinggal dalam baldi bocor mencapai jumlah permintaan maksimum. Jika ya, tolak permintaan baharu jika tidak, masukkan permintaan baharu ke dalam baldi dan kurangkan bilangan permintaan dalam baldi oleh seorang.

Algoritma baldi bocor boleh dilaksanakan dengan bantuan coroutine dan pemasa di Golang. Kami boleh menggunakan pemasa untuk mewakili baldi bocor kami yang mengalir keluar perlahan-lahan dari semasa ke semasa. Kodnya adalah seperti berikut:

type LeakyBucket struct {
    rate       float64 // 漏桶每秒处理的请求量（R）
    capacity   int     // 漏桶的大小（B）
    water      int     // 漏桶中当前的水量（当前等待处理的请求个数）
    lastLeaky  int64   // 上一次请求漏出的时间，纳秒
    leakyTimer *time.Timer // 漏桶接下来漏水需要等待的时间
    reject     chan int // 被拒绝的请求通道
}

func NewLeakyBucket(rate float64, capacity int) *LeakyBucket {
    bucket := &LeakyBucket{
        rate:     rate,
        capacity: capacity,
        water:    0,
        reject:   make(chan int, 1000),
    }
    bucket.leakyTimer = time.NewTimer(time.Second / time.Duration(rate))
    return bucket
}

func (lb *LeakyBucket) Request() chan int {
    select {
    case <-lb.leakyTimer.C:
        if lb.water > 0 {
            lb.water -= 1
            lb.leakyTimer.Reset(time.Second / time.Duration(lb.rate))
               return nil // 请求被允许
        }
        lb.leakyTimer.Reset(time.Second / time.Duration(lb.rate))
        return lb.reject // 请求被拒绝
    default:
        if lb.water >= lb.capacity {
            return lb.reject // 请求被拒绝
        } else {
            lb.water += 1 // 请求被允许
            return nil
        }
    }
}

Dalam contoh ini, kami menggunakan pemasa di Golang untuk merealisasikan kadar aliran keluar baldi bocor dan menggunakan chan untuk merealisasikan penimbalan permintaan. Kami mula-mula mencipta pemasa untuk memeriksa jumlah permintaan yang tinggal (air) dalam baldi yang bocor sebelum permintaan itu berlalu, kami akan menyemak dahulu sama ada ia telah mencapai kapasiti maksimum untuk diproses. jika tidak, kami akan Sila masukkan ke dalam baldi yang bocor dan tambah 1 kepada jumlah air.

Fikiran Lanjut

Dalam artikel ini, kami memperkenalkan dua algoritma pengehad semasa permintaan biasa: algoritma pengehad semasa berasaskan tetingkap dan algoritma baldi bocor. Walau bagaimanapun, terdapat banyak variasi lain bagi algoritma ini, seperti kawalan aliran berdasarkan kepentingan permintaan atau digunakan bersama dengan struktur data baris gilir. Golang sendiri mempamerkan model konkurensi dan coroutine yang sangat baik, menjadikannya salah satu alat terbaik untuk melaksanakan pendikitan permintaan.

Pada masa hadapan, dengan perkembangan lanjut kecerdasan buatan, data besar dan teknologi lain, kami memerlukan algoritma pengehad semasa yang lebih baik untuk menyokong operasi aplikasi kami. Jadi, sebelum kita berfikir lebih jauh, mari kita meneroka dan mengkaji bidang yang sentiasa berubah dan berkembang ini bersama-sama.

Atas ialah kandungan terperinci Cara menggunakan Golang untuk melaksanakan pengehadan semasa permintaan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!