Are golang net.UDPConn and net.TCPConn thread safe?? Can i read or write of single UDPConn object in multi thread?

1.Can we call send from one thread and recv from another on the same net.UDPConn or net.TCPConn objects?

2.Can we call multiple sends parallely from different threads on the same net.UDPConn or net.TCPConn objects?

I am unable to find a good documentation also for the same.
Is golang socket api thread safe?

I find that it is hard to test if it is thread safe.
Any pointers in the direction will be helpful.

My test code is below:

package main

import (
    "fmt"
    "net"
    "sync"
)

func udp_server() {
    // create listen
    conn, err := net.ListenUDP("udp", &net.UDPAddr{
	    IP:   net.IPv4(0, 0, 0, 0),
	    Port: 8080,
    })
    if err != nil {
	    fmt.Println("listen fail", err)
	    return
    }
    defer conn.Close()

    var wg sync.WaitGroup
    for i := 0; i < 10; i = i + 1 {
	    wg.Add(1)
	    go func(socket *net.UDPConn) {
		    defer wg.Done()
		    for {
			    // read data
			    data := make([]byte, 4096)
			    read, remoteAddr, err := socket.ReadFromUDP(data)
			    if err != nil {
				    fmt.Println("read data fail!", err)
				    continue
			    }
			    fmt.Println(read, remoteAddr)
			    fmt.Printf("%s\n\n", data)

			    // send data
			    senddata := []byte("hello client!")
			    _, err = socket.WriteToUDP(senddata, remoteAddr)
			    if err != nil {
				    return
				    fmt.Println("send data fail!", err)
			    }
		    }
	    }(conn)
    }
    wg.Wait()
}

func main() {
    udp_server()
}

Is it OK for this test code?

The documentation for net.Conn says:

> Multiple goroutines may invoke methods on a Conn simultaneously.

> Multiple goroutines may invoke methods on a Conn simultaneously.

My interpretation of the doc above, is that nothing catastrophic will happen if you invoke Read and Write on a net.Conn from multiple go routines, and that calls to Write on a net.Conn from multiple go routines will be serialised so that the bytes from 2 separate calls to Write will not be interleaved as they are written to the network.

The problem with the code you have presented is that there is no guarantee that Write will write the whole byte slice provided to it in one go. You are ignoring the indication of how many bytes have been written.

_, err = socket.WriteToUDP(senddata, remoteAddr)

So to make sure you write everything you would need to loop and call Write till all the senddata is sent. But net.Conn only ensures that data from a single call to Write is not interleaved. Given that you could be sending a single block of data with multiple calls to write there is no guarantee that the single block of data would reach its destination intact.

So for example 3 "hello client!" messages could arrive in the following form.

"hellohellohello client! client! client!"

So if you want reliable message writing on a net.Conn from multiple go routines you will need to synchronise those routines to ensure that single messages are written intact.

If I wanted to do this, as a first attempt I would have a single go routine reading from one or many message channels and writing to a net.Conn and then multiple go routines can write to those message channels.