Go语言TCP连接读取性能优化指南

// Handle the reads
var tbuf [81920]byte // 定义一个较大的缓冲区

for {
    n, err := c.rwc.Read(tbuf[0:]) // 从连接读取数据

    // 检查读取错误
    if err != nil {
        log.Printf("Could not read packet : %s", err.Error())
        break
    }

    log.Println(n) // 打印每次读取的字节数
}

package main

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

func handle(c net.Conn) {
    defer c.Close() // 确保连接关闭
    start := time.Now()
    tbuf := make([]byte, 81920) // 保持较大的读取缓冲区
    totalBytes := 0

    log.Printf("Handling connection from %s", c.RemoteAddr())

    for {
        n, err := c.Read(tbuf) // 从连接读取数据
        totalBytes += n

        // 检查读取错误
        if err != nil {
            if err != io.EOF { // io.EOF 表示连接正常关闭，不是错误
                log.Printf("Read error for %s: %s", c.RemoteAddr(), err)
            } else {
                log.Printf("Connection %s closed gracefully (EOF)", c.RemoteAddr())
            }
            break
        }
        // 记录每次读取的字节数，用于观察数据流
        // log.Printf("Read %d bytes from %s", n, c.RemoteAddr())
    }
    log.Printf("%s: %d bytes read in %s", c.RemoteAddr(), totalBytes, time.Since(start))
}

func main() {
    srv, err := net.Listen("tcp", ":2000") // 监听2000端口
    if err != nil {
        log.Fatalf("Failed to listen: %v", err)
    }
    log.Println("Listening on :2000")

    for {
        conn, err := srv.Accept() // 接受新连接
        if err != nil {
            log.Fatalf("Failed to accept connection: %v", err)
        }
        go handle(conn) // 为每个连接启动一个goroutine处理
    }
}

package main

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

func handle(c net.Conn) {
    defer c.Close() // 确保连接关闭
    start := time.Now()
    tbuf := make([]byte, 4096) // 每次写入4KB数据
    totalBytes := 0
    numWrites := 1000 // 写入1000次，总计4MB数据

    log.Printf("Sending %d bytes to %s in %d chunks of %d bytes", numWrites*len(tbuf), c.RemoteAddr(), numWrites, len(tbuf))

    for i := 0; i < numWrites; i++ {
        n, err := c.Write(tbuf) // 向连接写入数据
        totalBytes += n

        // 检查写入错误
        if err != nil {
            log.Printf("Write error to %s: %s", c.RemoteAddr(), err)
            break
        }
        // 记录每次写入的字节数
        // log.Printf("Wrote %d bytes to %s", n, c.RemoteAddr())
    }
    log.Printf("%s: %d bytes written in %s", c.RemoteAddr(), totalBytes, time.Since(start))
}

func main() {
    conn, err := net.Dial("tcp", "localhost:2000") // 连接到服务器
    if err != nil {
        log.Fatalf("Failed to dial: %v", err)
    }
    log.Println("Connected to localhost:2000")
    handle(conn)
}

import (
    "net"
    "log"
)

func handleConnection(conn net.Conn) {
    if tcpConn, ok := conn.(*net.TCPConn); ok {
        // 禁用Nagle算法
        err := tcpConn.SetNoDelay(true)
        if err != nil {
            log.Printf("Failed to set NoDelay: %v", err)
        }
    }
    // ... 其他连接处理逻辑
}

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

func handleBufferedConnection(conn net.Conn) {
    defer conn.Close()

    reader := bufio.NewReader(conn)
    writer := bufio.NewWriter(conn)

    // 示例：读取一行数据
    line, err := reader.ReadString('\n')
    if err != nil {
        if err != io.EOF {
            log.Printf("Read error: %v", err)
        }
        return
    }
    log.Printf("Received: %s", line)

    // 示例：写入数据并刷新缓冲区
    _, err = writer.WriteString("Hello from server!\n")
    if err != nil {
        log.Printf("Write error: %v", err)
        return
    }
    err = writer.Flush() // 确保数据被发送
    if err != nil {
        log.Printf("Flush error: %v", err)
    }
}

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

func handleWithDeadlines(conn net.Conn) {
    defer conn.Close()

    // 设置读取截止时间为10秒
    err := conn.SetReadDeadline(time.Now().Add(10 * time.Second))
    if err != nil {
        log.Printf("SetReadDeadline error: %v", err)
        return
    }

    buf := make([]byte, 1024)
    n, err := conn.Read(buf)
    if err != nil {
        if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
            log.Printf("Read timeout: %v", err)
        } else {
            log.Printf("Read error: %v", err)
        }
        return
    }
    log.Printf("Read %d bytes: %s", n, string(buf[:n]))

    // 每次读写操作后，通常需要重置截止时间
    err = conn.SetReadDeadline(time.Time{}) // 重置为无截止时间
    if err != nil {
        log.Printf("Reset ReadDeadline error: %v", err)
    }
}