Bagaimana untuk melaksanakan pengehadan arus dalam golang

Penghadan semasa ialah strategi biasa untuk mengelakkan beban sistem. Dengan mengehadkan kadar permintaan sistem, ketersediaan sistem boleh dijamin dan kehilangan data yang disebabkan oleh ranap sistem dapat dicegah. Dalam aplikasi kejuruteraan sebenar, pengehadan semasa sering diperlukan untuk memastikan kestabilan sistem. Artikel ini akan memperkenalkan cara menggunakan golang untuk melaksanakan fungsi mengehadkan semasa.

1. Algoritma pengehad semasa

Algoritma pengehad semasa merujuk kepada algoritma yang mengawal trafik dalam beberapa cara. Menggunakan algoritma pengehad semasa dalam program secara amnya bermakna mengawal kelajuan pemprosesan program. Algoritma pengehad semasa biasa termasuk algoritma baldi bocor dan algoritma baldi token.

Algoritma baldi bocor: Algoritma baldi bocor ialah baldi bocor dengan kapasiti tetap Air ditambahkan ke dalamnya pada kadar tertentu Apabila air melebihi kapasiti baldi, ia akan melimpah. Iaitu, jika air mengalir masuk lebih cepat daripada air mengalir keluar, baldi akan penuh dan air seterusnya akan dibuang.

Algoritma baldi token: Algoritma baldi token ialah baldi token berkapasiti tetap Token ditambahkan padanya pada kadar tertentu Setiap permintaan memerlukan satu token untuk diproses. Iaitu, jika token tidak mencukupi, permintaan akan dibuang.

2. Golang melaksanakan pengehadan semasa

Untuk melaksanakan fungsi pengehad semasa dalam golang, anda perlu menggunakan algoritma pengehadan semasa pada program serentak. Golang menyediakan pakej penyegerakan terbina dalam yang boleh digunakan untuk melaksanakan fungsi mengehadkan semasa.

Kod dilaksanakan seperti berikut:

package main

import (
    "fmt"
    "sync"
    "time"
)

type Limiter struct {
    sync.Mutex
    limit  int
    count  int
    expire time.Time
}

func NewLimiter(limit int, expire time.Duration) *Limiter {
    return &Limiter{
        limit:  limit,
        count:  0,
        expire: time.Now().Add(expire),
    }
}

func (limit *Limiter) Allow() bool {
    limit.Lock()
    defer limit.Unlock()

    if limit.count < limit.limit {
        limit.count++
        return true
    }

    if time.Now().After(limit.expire) {
        limit.count = 1
        limit.expire = time.Now().Add(time.Second)
        return true
    }

    return false
}

func main() {
    limit := NewLimiter(10, time.Second)
    for i := 0; i < 30; i++ {
        if limit.Allow() {
            fmt.Println(i, "allow")
        } else {
            fmt.Println(i, "deny")
        }
        time.Sleep(100 * time.Millisecond)
    }
}

Dalam kod di atas, kami mentakrifkan struktur Penghad, yang mengandungi tiga medan: had, kiraan dan tamat tempoh. Had mewakili bilangan permintaan yang dibenarkan sesaat, kiraan mewakili bilangan permintaan yang sedang diproses dan tamat tempoh mewakili masa tamat tempoh.

Buat objek Limiter melalui fungsi NewLimiter, dan masukkan had kuantiti permintaan dan masa tamat tempoh. Kaedah Allow digunakan untuk menyemak sama ada permintaan pada masa ini dibenarkan untuk diproses berdasarkan masa semasa dan had dan sekatan tamat tempoh serta mengemas kini medan kiraan dan tamat tempoh.

Dalam fungsi utama, kami menggunakan gelung untuk menguji sama ada Limiter boleh mengehadkan bilangan permintaan yang diproses sesaat dan menggunakan masa. Fungsi tidur untuk menjeda selama 100 milisaat.

3. Ringkasan

Fungsi pengehad semasa adalah keperluan yang sangat biasa dalam pembangunan program. Dengan mengehadkan kadar permintaan, anda boleh melindungi keselamatan dan kestabilan program anda. Artikel ini memperkenalkan cara melaksanakan fungsi mengehadkan semasa dalam golang Dengan menggunakan pakej penyegerakan dan objek Limiter, kami boleh melaksanakan kawalan aliran untuk program konkurensi tinggi dengan mudah.

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan pengehadan arus dalam golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!