我有一台服务器监听 2 个端口并在这 2 个端口之间传输消息。唯一的问题是每个客户端(或每个端口)必须先提交一条消息，然后才能接收到另一个端口发送的先前消息。例如，如果客户端 1 说“你好”，客户端 2 将不会收到消息，除非他先发送一条消息。

我想找到一种方法使每个客户端在发送新消息之前都必须接收到以前的消息。 (由于客户端 1 在客户端 2 说些什么之前不会收到任何内容，因此我计划向其发送一个包含占位符文本的字符串。)

谁能帮我解决这个问题？我尝试将我的监听代码和为每个客户编写消息的代码放入他们自己的 go 例程中，但这并没有完成工作。任何帮助将不胜感激。

这是我的代码:

服务器

package main

import (
    "fmt"
    "log"
    "net"
)

var message string = "Client 2 is receiving your message"

func main() {
    fmt.Println("The server is listening on Port 3000 and 8080")
    //Set up listeners for the ports each client is using
    listener, err := net.Listen("tcp", "localhost:3000")
    if err != nil {
        log.Fatal(err) 
    }
    listener2, err := net.Listen("tcp", "localhost:8080")
    if err != nil {
        log.Fatal(err)
    }
    go acceptLoop(listener)
    acceptLoop(listener2)  // run in the main goroutine
}

func acceptLoop(l net.Listener) {
    defer l.Close()
    for {
            c, err := l.Accept()
            if err != nil {
                log.Fatal(err)
            }
            fmt.Println("New connection found!")
            go listenConnection(c)
    }
}

func listenConnection(conn net.Conn) {
        fmt.Println("Yay")
        for {
                buffer := make([]byte, 1400)
                dataSize, err := conn.Read(buffer)
                if err != nil {
                    fmt.Println("Connection has closed")
                    return
                }

                //This is the message you received
                data := buffer[:dataSize]
                fmt.Print("Received message: ", string(data))

                // Send the message back
                _, err = conn.Write([]byte(message))
                if err != nil {
                        log.Fatalln(err)
                }
                fmt.Print("Message sent: ", string(data))
                message = string(data)
        }
}

客户1

    package main

import (
        "fmt"
        "log"
        "net"
        "bufio"
        "os"
)

func main() {
        conn, err := net.Dial("tcp", "localhost:3000")
        if err != nil {
                log.Fatalln(err)
        }

for {
        reader := bufio.NewReader(os.Stdin)
        fmt.Print("Enter text: ")
        text, _ := reader.ReadString('\n')

        _, err = conn.Write([]byte(text))
        if err != nil {
                log.Fatalln(err)
        }

        for {
                buffer := make([]byte, 1400)
                dataSize, err := conn.Read(buffer)
                if err != nil {
                        fmt.Println("The connection has closed!")
                        return
                }

                data := buffer[:dataSize]
                fmt.Println("Received message: ", string(data))
                break
        }

    }
}

除了“localhost:3000”被替换为“localhost:8080”之外，我的第二个客户端与第一个相同。

我将不胜感激任何帮助!我对网络和 Go 还很陌生，所以任何提示都会很棒。

最佳答案

现在您的 Server 只是一个回声。它使用从客户端收到的消息进行响应。

如果您想在两个客户端之间中继消息，您需要弄清楚的第一件事是如果有 3 个客户端连接(2 个连接到第一个端口，1 个连接到另一个端口)会发生什么情况？

如果您希望只有一个客户端连接到每个端口，您可以这样做(伪-go-code):

func main() {
  // ...
  # Channels must be buffered or else clients will deadlock.
  relay := make(chan string, 1)
  go acceptLoop(listener1, relay)
  acceptLoop(listener2, relay)
}

func acceptLoop(l, relay) {
  for {
    conn := l.Accept()
    for {
       relay <- conn.Read()
       conn.Write(<-relay)
    }
} 

关于networking - 在写消息之前接受消息，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36320044/