Question

我正在尝试建立一个基本的客户端/服务器体系结构，在该体系结构中，两者之间需要进行一些数据交换，并且双方都需要进行一些处理。因此，我的服务器有两个线程正在向客户端发送一些数据。我想知道如何将这些数据分别接收到两个不同的变量中。

尽管我仍然不确定，但我了解到，这与竞态条件，互斥锁等概念有关。我对它们有基本的了解，但从未实际使用它们。我想知道是否有一些针对此问题的预先设计的解决方案。

服务器端：

func handleConn(conn net.Conn) {
    go func() {
        io.WriteString(conn, "Text 1")
    }()
    go func() {
        io.WriteString(conn, "Text 2")
    }()
}

客户端：

func SocketClient(ip string, port string) {
    addr := strings.Join([]string{ip, port}, ":")
    conn, err := net.Dial("tcp", addr)

    defer conn.Close()

    if err != nil {
        log.Fatalln(err)
    }

    buff := make([]byte, 1024)
    n, _ := conn.Read(buff)
    log.Printf("Received: %s", buff[:n])
}

变量buff读取“文本1”和“文本2”。我想让它像有两个单独的变量buff1和buff2一样，分别保存两个文本。

Answer 1

您仅读取一次连接，并且您应该希望在一次呼叫中收到全部数据。您可以使用分隔符（如换行符）分隔消息，并在循环中通过该分隔符读取数据。这样，就像您收到了两条不同的消息。我制作了一个样本供您查看。

package main

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

func handleConn(conn net.Conn) {
    go func() {
        io.WriteString(conn, "Text 1\n")
    }()
    go func() {
        io.WriteString(conn, "Text 2\n")
    }()
}

func SocketClient() {
    conn, err := net.Dial("tcp", ":3000")
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()
    if err != nil {
        log.Fatalln(err)
    }
    reader := bufio.NewReader(conn)
    for {
        buff, err := reader.ReadString('\n')
        if err != nil {
            log.Fatalln(err)
        }
        log.Printf("Received: %s", buff)
    }
}

func main() {
    wg := &sync.WaitGroup{}
    wg.Add(1)
    go func() {
        a, _ := net.Listen("tcp", ":3000")
        wg.Done()
        for {
            conn, err := a.Accept()
            if err != nil {
                log.Fatalln(err)
            }
            handleConn(conn)
        }
    }()
    wg.Wait()
    SocketClient()
}

输出：

Received: Text 1
Received: Text 2

如何从服务器上运行的两个并发进程分别接收数据？

1 个答案: