So implementieren Sie mit Golang die Anforderungsstrombegrenzung

Mit der zunehmenden Nutzung moderner Netzwerkanwendungen beginnen viele Benutzeranfragen auf den Server zu strömen, was zu einigen Problemen führt. Einerseits ist die Serverleistung eingeschränkt und es gibt keine Garantie dafür, dass alle Anfragen verarbeitet werden können. Andererseits kann eine große Anzahl gleichzeitig eintreffender Anfragen zu Instabilität des Dienstes führen. Zu diesem Zeitpunkt ist die Begrenzung der Anforderungsrate zu einer unvermeidlichen Entscheidung geworden. Im Folgenden wird erläutert, wie Sie mit Golang die Anforderungsstrombegrenzung implementieren.

Was ist Strombegrenzung?

Strombegrenzung bezieht sich auf die Begrenzung der maximalen Anzahl von Anfragen oder des Datenverkehrs, die eine Anwendung, ein System oder ein Dienst innerhalb eines bestimmten Zeitraums aushalten kann. Die Strombegrenzung kann uns helfen, Netzwerkangriffe einzudämmen und Bandbreiten- und Ressourcenmissbrauch zu verhindern. Normalerweise nennen wir diese Grenze „Flusskontrolle“, die Anforderungen unterschiedlicher Art und Quelle priorisieren und Anforderungen unterschiedlicher Art und Quelle in unterschiedlichen Anteilen verarbeiten kann.

Implementierung der Anforderungsstrombegrenzung

Zeitfensterbasierter Fensterstrombegrenzungsalgorithmus

Der einfachste und direkteste Algorithmus ist der zeitfensterbasierte Strombegrenzungsalgorithmus . Es prüft, ob die Gesamtzahl der im letzten Zeitraum gesendeten Anfragen einen Schwellenwert überschreitet. Die Länge des Zeitfensters kann entsprechend den Eigenschaften der Anwendung angepasst werden, um eine optimale Leistung und eine minimale Fehlalarmrate zu erreichen.

Angenommen, wir müssen die maximale Anzahl von Zugriffen pro Sekunde auf eine API begrenzen. Wir können das Zeitpaket in Golang verwenden, um den Datenverkehr zu zählen und Pufferkanäle zum Implementieren von Anforderungswarteschlangen zu verwenden. Der Code lautet wie folgt:

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
}

In diesem Beispiel verwenden wir Chan in Golang, um die Anforderungswarteschlange zu implementieren, und verwenden das Zeitpaket, um die Anzahl der Anforderungen innerhalb des Zeitfensters zu berechnen. Nachdem jede Anfrage den Server erreicht hat, stellen wir die Anfrage in die Warteschlange und vergleichen das Anfragevolumen auch mit der maximalen Anzahl von Anfragen. Wenn die maximale Anzahl von Anfragen überschritten wird, wird „false“ zurückgegeben.

Leaky-Bucket-Algorithmus

Der Leaky-Bucket-Algorithmus ist ein weiterer berühmter Strombegrenzungsalgorithmus. Der Leaky-Bucket behält jederzeit eine bestimmte Anzahl von Anforderungen. Wenn eine neue Anfrage eintrifft, prüfen Sie zunächst, ob die Anzahl der im Leaky-Bucket verbleibenden Anfragen die maximale Anfragemenge erreicht. Wenn ja, lehnen Sie die neue Anfrage ab, andernfalls legen Sie die neue Anfrage in den Bucket und reduzieren Sie die Anzahl der Anfragen im Bucket um eins.

Der Leaky-Bucket-Algorithmus kann mithilfe von Coroutinen und Timern in Golang implementiert werden. Wir können einen Timer verwenden, um darzustellen, wie aus unserem Leaky-Bucket im Laufe der Zeit langsam Anfragen herausfließen. Der Code lautet wie folgt:

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
        }
    }
}

In diesem Beispiel verwenden wir den Timer in Golang, um die Abflussrate des Leaky-Buckets zu realisieren, und verwenden Chan, um die Anforderungspufferung zu realisieren. Wir haben zunächst einen Timer erstellt, um regelmäßig die verbleibende Anzahl der Anfragen (Wasser) im Leaky-Bucket zu überprüfen. Bevor die Anfrage erfolgreich ist, prüfen wir zunächst, ob die maximale Kapazität zur Verarbeitung erreicht ist. Wenn ja, werden wir eine Ablehnung zurückgeben. Wenn nicht, geben wir es bitte in einen undichten Eimer und fügen 1 zur Wassermenge hinzu.

Weitere Gedanken

In diesem Artikel stellen wir zwei gängige Anforderungsstrombegrenzungsalgorithmen vor: den fensterbasierten Strombegrenzungsalgorithmus und den Leaky-Bucket-Algorithmus. Es gibt jedoch viele andere Variationen dieser Algorithmen, beispielsweise eine Flusskontrolle basierend auf der Wichtigkeit der Anforderung oder in Verbindung mit Warteschlangendatenstrukturen. Golang selbst weist hervorragende Parallelitäts- und Coroutine-Modelle auf und ist damit eines der besten Tools für die Implementierung der Anforderungsdrosselung.

In Zukunft werden wir mit der tiefgreifenden Entwicklung von künstlicher Intelligenz, Big Data und anderen Technologien bessere Strombegrenzungsalgorithmen benötigen, um den Betrieb unserer Anwendungen zu unterstützen. Bevor wir also weiter nachdenken, lassen Sie uns gemeinsam dieses sich ständig verändernde und weiterentwickelnde Gebiet erkunden und studieren.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie mit Golang die Anforderungsstrombegrenzung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!