Warum ist meine Go-Unix-Socket-Verbindung unidirektional und wie kann ich das beheben?

Unix-Sockets in Go: Ein unidirektionales Verbindungsproblem

Eine häufige Herausforderung bei der Arbeit mit Unix-Sockets in Go besteht darin, dass die Verbindung manchmal unterbrochen werden kann unidirektional. Während Daten von einer Partei empfangen werden können, führt das Zurücksenden von Daten zu keiner Antwort.

Lassen Sie uns ein Codebeispiel in einem Forenthread analysieren, um die Ursache zu identifizieren:

Servercode:

func echoServer(c net.Conn) {
    for {
        buf := make([]byte, 512)
        nr, err := c.Read(buf)
        if err != nil {
            return
        }

        data := buf[0:nr]
        fmt.Printf("Received: %v", string(data))
        _, err = c.Write(data)
        if err != nil {
            panic("Write: " + err.String())
        }
    }
}

Kunde Code:

func main() {
    c,err := net.Dial("unix","", "/tmp/echo.sock")
    if err != nil {
        panic(err.String())
    }
    for {
        _,err := c.Write([]byte("hi\n"))
        if err != nil {
            println(err.String())
        }
        time.Sleep(1e9)
    }
}

Beim Überprüfen des Codes stellen wir fest, dass der Client die vom Server gesendete Antwort nicht liest. Dies verursacht ein Problem, bei dem der Client weiterhin Daten an den Server sendet, aber nie eine Antwort erhält.

Lösung:

Um dieses Problem zu beheben, müssen wir eine hinzufügen Goroutine im Client, um das Lesen der Antwort vom Server zu übernehmen. Nach dieser Änderung funktioniert der Code wie vorgesehen:

Überarbeiteter Servercode:

func echoServer(c net.Conn) {
    for {
        buf := make([]byte, 512)
        nr, err := c.Read(buf)
        if err != nil {
            return
        }

        data := buf[0:nr]
        println("Server got:", string(data))
        _, err = c.Write(data)
        if err != nil {
            log.Fatal("Write: ", err)
        }
    }
}

Überarbeiteter Client-Code:

func reader(r io.Reader) {
    buf := make([]byte, 1024)
    for {
        n, err := r.Read(buf[:])
        if err != nil {
            return
        }
        println("Client got:", string(buf[0:n]))
    }
}

func main() {
    c, err := net.Dial("unix", "/tmp/echo.sock")
    if err != nil {
        panic(err)
    }
    defer c.Close()

    go reader(c)
    for {
        _, err := c.Write([]byte("hi"))
        if err != nil {
            log.Fatal("write error:", err)
            break
        }
        time.Sleep(1e9)
    }
}

Mit diesen Änderungen kann der Server Daten vom Client empfangen und auch Antworten zurücksenden, was zu einer bidirektionalen Kommunikation führt Kanal.

Das obige ist der detaillierte Inhalt vonWarum ist meine Go-Unix-Socket-Verbindung unidirektional und wie kann ich das beheben?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!