Go Academy · บทเรียน

การจัดการการเชื่อมต่อ

จัดการการตัดการเชื่อมต่อ

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

การเชื่อมต่อไม่ได้คงอยู่ตลอดไป

ไคลเอ็นต์อาจปิดแท็บ สูญเสียสัญญาณ Wi-Fi หรือหยุดทำงาน เซิร์ฟเวอร์ WebSocket ที่แข็งแกร่งต้องตรวจจับการยกเลิกการเชื่อมต่อ เก็บกวาดทรัพยากร และคืนกอรูทีน ไม่เช่นนั้นจะเกิดหน่วยความจำและซ็อกเก็ตรั่ว

การจับมือเพื่อปิดการเชื่อมต่อ

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

if websocket.IsCloseError(err, websocket.CloseNormalClosure) {
    // graceful close
}

การคงการเชื่อมต่อด้วย Ping/Pong

เพื่อค้นหาการเชื่อมต่อที่อีกฝ่ายหายไปโดยไม่ปิดการเชื่อมต่อ เซิร์ฟเวอร์จะส่งเฟรมควบคุม ping เป็นระยะและคาดหวังการตอบกลับ pong

conn.SetPongHandler(func(string) error {
    conn.SetReadDeadline(time.Now().Add(60 * time.Second))
    return nil
})

กำหนดเวลาการอ่าน

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

conn.SetReadDeadline(time.Now().Add(60 * time.Second))

ตัวนับจังหวะ Ping

ตัวนับจังหวะในกอรูทีนตัวเขียนจะส่ง ping เป็นระยะ หากการเขียนล้มเหลว แสดงว่าการเชื่อมต่อใช้งานไม่ได้แล้ว ให้จบการทำงาน

ticker := time.NewTicker(54 * time.Second)
defer ticker.Stop()
for range ticker.C {
    if err := conn.WriteMessage(websocket.PingMessage, nil); err != nil {
        return
    }
}

การเก็บกวาดเมื่อจบการทำงาน

เมื่ออ่านหรือเขียนจบลูป ให้ยกเลิกการลงทะเบียนไคลเอ็นต์และปิดการเชื่อมต่อ defer ช่วยให้การทำงานนี้เชื่อถือได้แม้เกิดความตื่นตระหนก

defer func() {
    hub.unregister <- client
    conn.Close()
}()

กอรูทีนสองตัวต่อการเชื่อมต่อหนึ่งรายการ

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

กำหนดเวลาการเขียนด้วย

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

conn.SetWriteDeadline(time.Now().Add(10 * time.Second))

การปิดเซิร์ฟเวอร์อย่างเรียบร้อย

เมื่อเซิร์ฟเวอร์กำลังปิดการทำงาน ให้ส่งเฟรมปิดไปยังไคลเอ็นต์แต่ละรายและรอชั่วครู่ ใช้ร่วมกับ http.Server.Shutdown และกำหนดเวลาสิ้นสุดของบริบท

conn.WriteMessage(websocket.CloseMessage,
    websocket.FormatCloseMessage(websocket.CloseGoingAway, "bye"))

การเชื่อมต่อใหม่บนไคลเอ็นต์

การยกเลิกการเชื่อมต่อเป็นเรื่องปกติ ไคลเอ็นต์ควรใช้ตรรกะการเชื่อมต่อใหม่แบบหน่วงเวลาเพิ่มขึ้นเป็นทวีคูณ ฝั่งเซิร์ฟเวอร์เพียงต้องจัดการการเชื่อมต่อและการยกเลิกการเชื่อมต่อแต่ละครั้งอย่างเรียบร้อย

ตัวอย่างที่รันได้: การตรวจจับการหมดเวลา

การคงการเชื่อมต่อของ WebSocket ต้องใช้ไลบรารี โปรแกรมที่ใช้ไลบรารีมาตรฐานนี้จำลองการตรวจสอบว่ายังทำงานอยู่โดยอาศัยกำหนดเวลาและช่องสัญญาณ

package main

import (
    "fmt"
    "time"
)

func main() {
    pong := make(chan struct{})
    go func() {
        time.Sleep(20 * time.Millisecond) // simulate a slow/absent peer
        _ = pong                          // no pong sent -> dead connection
    }()
    select {
    case <-pong:
        fmt.Println("alive")
    case <-time.After(10 * time.Millisecond):
        fmt.Println("no pong: closing dead connection")
    }
}

ตรวจสอบความเข้าใจ

ทดสอบความเข้าใจเรื่องการจัดการการเชื่อมต่อ

สรุปทบทวน

คุณได้เรียนรู้การจัดการการเชื่อมต่อดังนี้:

จัดการการจับมือเพื่อปิดการเชื่อมต่อและตรวจสอบรหัสปิด
ใช้ ping/pong ร่วมกับกำหนดเวลาการอ่านและการเขียนเพื่อตรวจจับการเชื่อมต่อกับอีกฝ่ายที่ขาดหาย
เรียกใช้ readPump และ writePump แล้วเก็บกวาดด้วย defer
ปิดการทำงานอย่างเรียบร้อยด้วยเฟรมปิด ส่วนไคลเอ็นต์จะเชื่อมต่อใหม่โดยใช้การหน่วงเวลาเพิ่มขึ้น

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

บทเรียน “การจัดการการเชื่อมต่อ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การจัดการการเชื่อมต่อ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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