Question

我有一个闭包，我声明并定义局部变量：

func writer_factory() func() *net.TCPConn {

    response_port := "localhost:8000"
    tcpAddr_res, err := net.ResolveTCPAddr("tcp4", response_port)
    checkError(err)
    var response_writer *net.TCPConn
    checkError(err)
    return func() *net.TCPConn {
        if response_writer == nil{
            response_writer, err = net.DialTCP("tcp", nil, tcpAddr_res)
            checkError(err)
        }
        return response_writer
    }
}

现在我的问题是，如果我多次调用此writer_factory，我会得到内存泄漏吗？

具体来说，我是否会在此程序中使用writer_factory进行内存泄漏：

package main


import (
    "fmt"
    "net"
    "os"
    "strings"
//  "io/ioutil"


)

//fmt.Printf("messages are (1) %q\n", messages)

func main() {

    end_of_message_terminator := "||"
    beginning_of_next_message := ""
    request := make([]byte, 512)

    service_port := ":7777"
    tcpAddr, err := net.ResolveTCPAddr("tcp4", service_port)
    checkError(err)
    listener, err := net.ListenTCP("tcp", tcpAddr)
    checkError(err)



    for {
        response_writer := writer_factory()

        conn, err := listener.Accept()

        if err != nil {

            continue

        }

        read_len, err := conn.Read(request)

        if read_len == 0 {
            continue
        }

        request_string := string(request[:read_len])


        messages := strings.Split(request_string, end_of_message_terminator)


        messages[0] = beginning_of_next_message + messages[0]

        if messages[len(messages) - 1] != "" {
            beginning_of_next_message = messages[len(messages) - 1]
            messages[len(messages) - 1] = ""

        }

        if len(messages) == 1 {
            continue
        }

        rw := response_writer()
        join_channel := make(chan struct{})
        for i := 0; i < len(messages); i++ {


            go func(i int, rw  *net.TCPConn){

                respond_to_message(messages[i], rw)
                join_channel <- struct{}{}

            }(i, rw)


        }

        go func (){

            for i := 0; i < len(messages); i++ {

                <- join_channel

            }


            rw.Close()

        }()
        conn.Close()


    }

}


func writer_factory() func() *net.TCPConn {

    response_port := "localhost:8000"
    tcpAddr_res, err := net.ResolveTCPAddr("tcp4", response_port)
    checkError(err)
    var response_writer *net.TCPConn
    checkError(err)
    return func() *net.TCPConn {
        if response_writer == nil{
            response_writer, err = net.DialTCP("tcp", nil, tcpAddr_res)
            checkError(err)
        }
        return response_writer
    }
}


func respond_to_message(message string, response_writer *net.TCPConn){

    message_parameters := strings.Split(message, "|")

    //response_writer.Write([]byte("asti de chris"))
    for i := range message_parameters {




        param_parts := strings.Split(message_parameters[i], "=")

        param_name := param_parts[0]

        //param_value := param_parts[1]


        response_writer.Write([]byte(param_name))

        //fmt.Println(string(result))




    }


}


func checkError(err error) {

    if err != nil {

        fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
        os.Exit(1)

    }

}

要练习此代码，请启动该程序，然后启动此程序netcat -l -p 8000，然后启动此程序printf "asti||" | netcat localhost 7777

Answer 1

您可以通过使用一个连接或（如果一个连接不是线程保存）使用sync.Pool来提高性能。这样可以节省你的内存分配（以及垃圾收集），也可以浪费时间来打开所有这些tcp连接。

Go中的内存管理

1 个答案: