Go Academy · บทเรียน

การหน่วงเวลาและลองใหม่

ลองใหม่โดยเพิ่มช่วงหน่วง

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

เหตุใดจึงลองใหม่

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

การลองใหม่แบบไม่ระวังเป็นอันตราย

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

การหน่วงเวลาแบบทวีคูณ

การหน่วงเวลาแบบทวีคูณจะเพิ่มเวลารอเป็นสองเท่าหลังความล้มเหลวแต่ละครั้ง: 100 มิลลิวินาที, 200 มิลลิวินาที, 400 มิลลิวินาที, 800 มิลลิวินาที วิธีนี้เปิดโอกาสให้บริการปลายทางฟื้นตัว

delay := 100 * time.Millisecond
for attempt := 0; attempt < 5; attempt++ {
    // try, on failure:
    time.Sleep(delay)
    delay *= 2
}

การเพิ่มการสุ่มหน่วงเวลา

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

jitter := time.Duration(rand.Int63n(int64(delay) / 2))
time.Sleep(delay + jitter)

การจำกัดเวลาหน่วง

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

if delay > 2*time.Second {
    delay = 2 * time.Second
}

การจำกัดจำนวนครั้ง

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

ลองใหม่เฉพาะงานไอดีมโพเทนต์

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

การลองใหม่พร้อมการหน่วงเวลาแบบทวีคูณครบถ้วน

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

package main

import (
    "errors"
    "fmt"
    "time"
)

func flaky(attempt int) error {
    if attempt < 2 {
        return errors.New("temporary failure")
    }
    return nil
}

func main() {
    delay := 50 * time.Millisecond
    var err error
    for attempt := 0; attempt < 5; attempt++ {
        err = flaky(attempt)
        if err == nil {
            fmt.Println("succeeded on attempt", attempt)
            return
        }
        fmt.Printf("attempt %d failed, waiting %v\n", attempt, delay)
        time.Sleep(delay)
        delay *= 2
    }
    fmt.Println("gave up:", err)
}

การเคารพบริบท

ส่ง context เข้าไปในลูปการลองใหม่ และเลือกทำงานกับ ctx.Done() ระหว่างการหลับรอ วิธีนี้ทำให้ผู้เรียกที่ถูกยกเลิกหรือหมดเวลาหยุดการลองใหม่ได้ทันที

select {
case <-ctx.Done():
    return ctx.Err()
case <-time.After(delay):
}

การแยกแยะข้อผิดพลาด

ข้อผิดพลาดไม่ใช่ทุกประเภทที่จะลองใหม่ได้ คำขอ 400 Bad Request จะล้มเหลวตลอดไป ให้ตรวจสอบข้อผิดพลาดหรือรหัสสถานะ และลองใหม่เฉพาะประเภทชั่วคราว เช่น การหมดเวลา, 429 และ 5xx

ตัวตัดวงจร

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

ตรวจสอบอย่างรวดเร็ว

ทดสอบความรู้เกี่ยวกับการหน่วงเวลาแบบทวีคูณของคุณ

สรุป

คุณได้เรียนรู้การหน่วงเวลาและการลองใหม่:

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

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

บทเรียน “การหน่วงเวลาและลองใหม่” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การหน่วงเวลาและลองใหม่”

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

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

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

บทเรียน “การหน่วงเวลาและลองใหม่” ใช้เวลานานแค่ไหน

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

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

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

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

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