Go Academy · บทเรียน

แนวคิดบักเก็ตโทเค็น

จำกัดอัตราคำขอ

แนวคิดบักเก็ตโทเค็น เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

เหตุผลที่ต้องจำกัดอัตรา

การจำกัดอัตรา จะจำกัดจำนวนการดำเนินการที่เกิดขึ้นต่อหน่วยเวลา ช่วยปกป้องส่วนติดต่อโปรแกรมประยุกต์จากการใช้งานในทางที่ผิด เคารพโควตาของผู้ให้บริการภายนอก และช่วยให้ระบบยังคงเสถียรเมื่อมีภาระงานสูง

ป้องกันการทำงานเกินกำลัง
บังคับใช้การใช้งานอย่างเป็นธรรม
ปฏิบัติตามขีดจำกัดของระบบต้นทาง

แบบจำลองถังโทเคน

ลองนึกภาพถังที่เก็บโทเคนไว้ คำขอแต่ละรายการต้องนำโทเคนออกไปหนึ่งรายการจึงจะดำเนินการต่อได้ โทเคนจะถูกเติมกลับด้วยอัตราคงที่ หากถังว่าง คำขอจะต้องรอหรือถูกปฏิเสธ

อัตราและการพุ่งเป็นช่วง

พารามิเตอร์สองตัวกำหนดถังโทเคน ได้แก่ อัตรา (จำนวนโทเคนที่เพิ่มต่อวินาที) และ การพุ่งเป็นช่วง (ความจุของถัง) การพุ่งเป็นช่วงช่วยรองรับการเพิ่มขึ้นชั่วคราวที่สูงกว่าอัตราคงที่

การเติมตามเวลา

หากอัตราคือโทเคน 5 รายการต่อวินาที จะมีโทเคนปรากฏขึ้นประมาณหนึ่งรายการทุก 200 มิลลิวินาที ถังจะไม่เก็บโทเคนเกินความจุการพุ่งเป็นช่วง ดังนั้นความจุที่ไม่ได้ใช้จะไม่สะสมไปตลอด

การรองรับการพุ่งเป็นช่วง

การพุ่งเป็นช่วงขนาด 10 หมายความว่าสามารถส่งคำขอได้ทันทีถึง 10 รายการ หากถังเต็ม หลังจากนั้นคำขอจะถูกควบคุมจังหวะตามอัตราคงที่ วิธีนี้ช่วยสร้างสมดุลระหว่างการตอบสนองที่รวดเร็วกับการควบคุม

การตรวจสอบตามเวลาอย่างง่าย

คุณสามารถประมาณการจำกัดอัตราได้ด้วยตัวสร้างสัญญาณตามเวลาที่ปล่อยสิทธิ์ตามช่วงเวลาคงที่ คำขอแต่ละรายการจะรอจังหวะสัญญาณถัดไป

ticker := time.NewTicker(200 * time.Millisecond)
defer ticker.Stop()
for i := 0; i < 3; i++ {
    <-ticker.C
    fmt.Println("request", i)
}

ถังโทเคนเทียบกับถังรั่ว

ถังรั่ว จะระบายออกด้วยอัตราคงที่และทำให้ผลลัพธ์ราบเรียบทั้งหมด จึงไม่อนุญาตให้เกิดการพุ่งเป็นช่วง ส่วน ถังโทเคน อนุญาตให้เกิดการพุ่งเป็นช่วงได้ถึงความจุของถัง ถังโทเคนพบได้บ่อยกว่าสำหรับการจำกัดการใช้งานส่วนติดต่อโปรแกรมประยุกต์

การจำลองถังโทเคนอย่างง่าย

ตัวอย่างที่เรียกใช้งานได้นี้จำลองถังโทเคนความจุ 3 รายการ ซึ่งเติมทุก 100 มิลลิวินาที และแสดงว่าคำขอใดได้รับอนุญาต

package main

import (
    "fmt"
    "time"
)

func main() {
    tokens := 3
    last := time.Now()
    rate := 100 * time.Millisecond
    for i := 0; i < 6; i++ {
        elapsed := time.Since(last)
        refill := int(elapsed / rate)
        if refill > 0 {
            tokens += refill
            if tokens > 3 {
                tokens = 3
            }
            last = time.Now()
        }
        if tokens > 0 {
            tokens--
            fmt.Println("request", i, "allowed")
        } else {
            fmt.Println("request", i, "rejected")
        }
        time.Sleep(40 * time.Millisecond)
    }
}

Allow เทียบกับ Wait และ Reserve

ตัวจำกัดอัตรามักมีพฤติกรรมให้เลือกสามแบบ: Allow ส่งคืนค่า true หรือ false ทันที Wait หยุดรอจนกว่าจะมีโทเคนว่าง และ Reserve แจ้งว่าต้องรอนานเท่าใด ให้เลือกตามว่าคุณสามารถหยุดรอได้หรือไม่

ขีดจำกัดอยู่ที่ใด

การจำกัดอัตราอาจกำหนดต่อไคลเอนต์ ต่อจุดเชื่อมต่อ หรือทั้งระบบ แผนที่ของตัวจำกัดอัตราที่ใช้ IP ของไคลเอนต์เป็นกุญแจจะบังคับใช้โควตาต่อไคลเอนต์ ส่วนตัวจำกัดอัตราร่วมเพียงตัวเดียวจะจำกัดปริมาณงานรวม

การเลือกพารามิเตอร์

กำหนดอัตราให้สอดคล้องกับโควตาของระบบปลายทาง หากส่วนติดต่อโปรแกรมประยุกต์อนุญาต 600 คำขอต่อนาที ให้กำหนดอัตราเป็น 10 รายการต่อวินาที กำหนดการพุ่งเป็นช่วงให้รองรับการเพิ่มขึ้นที่คาดไว้โดยไม่เกินค่าเฉลี่ย

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจของคุณเกี่ยวกับถังโทเคน

สรุปทบทวน

คุณได้เรียนรู้แนวคิดถังโทเคนดังนี้:

โทเคนถูกใช้ไปกับคำขอแต่ละรายการและเติมกลับตามอัตรา
การพุ่งเป็นช่วงคือความจุของถังสำหรับรองรับการเพิ่มขึ้นชั่วคราว
ถังโทเคนรองรับการพุ่งเป็นช่วง แต่ถังรั่วไม่รองรับ
Allow, Wait และ Reserve คือส่วนติดต่อที่ใช้กันทั่วไป

คำถามที่พบบ่อย

บทเรียน “แนวคิดบักเก็ตโทเค็น” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “แนวคิดบักเก็ตโทเค็น” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “แนวคิดบักเก็ตโทเค็น”

จำกัดอัตราคำขอ คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “แนวคิดบักเก็ตโทเค็น” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม

ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Go Academy