Bagaimana untuk Mematikan Pelayan Go Listening dengan Anggun?

Cara Menghentikan Pelayan Mendengar dengan Anggun dalam Go

Dalam Go, dengar.Terima fungsi menyekat pelaksanaan, menjadikannya mencabar untuk menamatkan sesuatu pelayan mendengar dengan anggun. Untuk menentukan masa untuk menamatkan pelayan, satu pendekatan ialah menutup soket mendengar dan mengesan ralat khusus yang menunjukkan sambungan rangkaian tertutup. Walau bagaimanapun, ralat ini tidak dieksport oleh pakej bersih, menyebabkan pembangun terpaksa menggunakan pengendalian ralat yang janggal.

Nasib baik, terdapat penyelesaian yang lebih elegan. Dengan menggunakan saluran selesai, anda boleh memberi isyarat kepada pelayan untuk berhenti sebelum menutup sambungan. Begini cara ia boleh dilaksanakan dengan kod sampel:

package main

import (
    "io"
    "log"
    "net"
    "sync"
    "time"
)

// Echo server struct
type EchoServer struct {
    listen net.Listener
    done   sync.WaitGroup
}

// Respond to incoming connection
//
// Write the address connected to then echo
func (es *EchoServer) respond(remote *net.TCPConn) {
    defer remote.Close()
    _, err := io.Copy(remote, remote)
    if err != nil {
        log.Printf("Error: %s", err)
    }
}

// Listen for incoming connections
func (es *EchoServer) serve() {
    for {
        conn, err := es.listen.Accept()
        if err != nil {
            select {
            case <-es.done:
                // Server has been stopped, so we can exit without showing the error.
            default:
                log.Printf("Accept failed: %v", err)
            }
            return
        }
        es.done.Add(1) // Increment the waitgroup for each incoming connection
        go func() {
            es.respond(conn.(*net.TCPConn))
            es.done.Done() // Decrement the waitgroup when done handling the connection
        }()
    }
}

// Stop the server by closing the listening listen
func (es *EchoServer) stop() {
    es.done.Wait() // Wait for all outstanding connections to finish handling
    es.listen.Close() // Now it the Accept will have an error above
}

// Make a new echo server
func NewEchoServer(address string) *EchoServer {
    listen, err := net.Listen("tcp", address)
    if err != nil {
        log.Fatalf("Failed to open listening socket: %s", err)
    }
    es := &amp;EchoServer{
        listen: listen,
    }
    es.done.Add(1)
    go es.serve()
    return es
}

// Main
func main() {
    log.Println("Starting echo server")
    es := NewEchoServer("127.0.0.1:18081")
    // Run the server for 1 second
    time.Sleep(1 * time.Second)
    // Close the server
    log.Println("Stopping echo server")
    es.stop()
}

Dalam kod ini, fungsi servis menamatkan pelayan dengan anggun dengan mengembalikan apabila nilai diterima pada saluran yang telah selesai. Fungsi utama menunjukkan cara untuk memulakan pelayan, menunggu sambungan, dan kemudian menamatkannya dengan anggun. Dengan menggunakan saluran yang telah selesai, pengendalian ralat dipisahkan dengan bersih daripada logik penutupan, menghasilkan pelayan yang lebih boleh diselenggara dan bebas ralat.

Atas ialah kandungan terperinci Bagaimana untuk Mematikan Pelayan Go Listening dengan Anggun?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!