使用 Golang TCP 连接在本地主机上进行高速数据传输

在使用 Go 语言 TCP 连接进行本地主机数据传输时，测量数据传输速率时出现异常值。尽管数据传输量应与字节数组长度相关，但测试结果显示数据量始终很高，且与数组长度无关。通过在服务器中添加打印语句，发现实际数据传输量与数组长度相关，表明在没有打印语句的情况下，字节数组长度被忽略。

问题

我用 go 编写了一个 tcp 回显服务器，我试图在 10 秒内尽可能频繁地写入/读取，以测量这段时间传输了多少数据。奇怪的是，这个值太高了，并且不依赖于我正在传输的字节数组的长度（但它应该！）。这 10 秒内始终有大约 600k 个连接（“结果”数组的长度描述了在这 10 秒内建立了多少连接）。一旦我向服务器添加一条打印语句并且值得到处理，我就会得到更实际的值，这些值取决于字节数组的长度。 为什么在第一种情况下字节数组的长度并不重要？

代码

服务器

package main

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

func main() {

    tcpaddr, err := net.resolvetcpaddr("tcp", fmt.sprintf("127.0.0.1:8888"))
    checkerror(err)

    ln, err := net.listentcp("tcp", tcpaddr)
    checkerror(err)

    for {
        conn, err := ln.accept()
        checkerror(err)

        go handleconnection(conn)
    }
}

func checkerror(err error) {
    if err != nil {
        log.fatal(err)
    }
}

func handleconnection(conn net.conn) {
    var input [1000000]byte

    for {
        n, err := conn.read(input[0:])
        checkerror(err)

        //fmt.println(input[0:n])

        _, err = conn.write(input[0:n])
        checkerror(err)
    }

}

客户端

package main

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

var (
    result  []int
    elapsed time.Duration
)

func main() {
    input := make([]byte, 1000)

    tcpAddr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:8888")
    checkError(err)

    conn, err := net.DialTCP("tcp", nil, tcpAddr)
    checkError(err)

    for start := time.Now(); time.Since(start) < time.Second*time.Duration(10); {

        startTimer := time.Now()
        _, err = conn.Write(input)
        checkError(err)

        _, err := conn.Read(input[0:])
        checkError(err)

        elapsed = time.Since(startTimer)
        result = append(result, int(elapsed))

    }

    fmt.Println(fmt.Sprintf("result: %v", len(result)))

}

func checkError(err error) {
    if err != nil {
        log.Fatal(err)
    }
}

解决方案

客户端循环中的read不保证读取先前调用write时发送的所有数据。

当 input 小到足以在网络上以单个数据包传输时，客户端中的 read 返回之前调用客户端中的 write 时的所有数据。在此模式下，应用程序测量执行请求/响应对的时间。

对于较大尺寸的 input，在客户端上读取可能会落后于客户端正在写入的内容。发生这种情况时，对 read 的调用完成得更快，因为这些调用从先前对 write 的调用返回数据。应用程序在此模式下进行流水线操作。流水线的吞吐量高于请求/响应对的吞吐量。该模式下客户端不会读取所有数据，但对时序的影响并不大。

使用以下代码为任意大小的 input 的请求/响应对计时。

for start := time.now(); time.since(start) < time.second*time.duration(10); {
    starttimer := time.now()
    _, err = conn.write(input)
    checkerror(err)

    _, err := io.readfull(conn, input) // <-- read all of the data
    checkerror(err)

    elapsed = time.since(starttimer)
    result = append(result, int(elapsed))
}

要测量完整的流水线，请修改客户端以从不同的 goroutine 读取和写入。下面是一个示例。

go func() {
    for start := time.Now(); time.Since(start) < time.Second*time.Duration(10); {
        _, err = conn.Write(input)
        checkError(err)
    }
    conn.CloseWrite() // tell server that we are done sending data
}()

start := time.Now()

output := make([]byte, 4096)
for {
    _, err := conn.Read(output)
    if err != nil {
        if err == io.EOF {
            break
        }
        checkError(err)
    }
}

fmt.Println(time.Since(start))

终于介绍完啦！小伙伴们，这篇关于《使用 Golang TCP 连接在本地主机上进行高速数据传输》的介绍应该让你收获多多了吧！欢迎大家收藏或分享给更多需要学习的朋友吧~golang学习网公众号也会发布Golang相关知识，快来关注吧！