concurrency | goroutines | golang | buffered reader

Believe I am either misunderstanding how go routines work, how buffered readers work or both.

Expect an asynchronous execution of the goroutine ( a buffered reader with a for loop reading the buffer, waiting for a message from the server )

Try METHOD A to call go xyz() before the client dials the server; so xyz() creates the buffer and starts reading in the background. Then, the client dials the server; server sends message back; the client is reading the buffer so, it gets the message and prints to console

What Actually Happens the client to send the message to the server, but does not pick up anything on the buffer while reading for possible reply from server; so it is running concurrently because I know the for loop has not stopped, but it lets the next line of code execute ( client sending message to server ).

But When METHOD B I call xyz() NOT concurrently and after the client dials the server, all things work as expected. The client gets the message back from the server and prints to console.

METHOD A, we have the order :

///////////// steps 1 and 2 are in the goroutine called by go xyz()

1. creates the buffered reader

2. for loop -- reading the buffer for message from the server -- print out

3. client dials the server

   go xyz(conn, p)

   fmt.Fprintf(conn, "Give me a hash to work on ...")

METHOD B, we have the order :

///////////// steps 2 and 3 are in the goroutine called by xyz()

1. client dials the server

2. creates buffered reader

3. for loop -- reading the buffer for message from the server -- print out

   fmt.Fprintf(conn, "Give me a hash to work on ...")

   xyz(conn, p)

client.go

package main
import (
    "fmt"
    "net"
    "bufio"
)

func xyz(conn net.Conn, p []byte) {
  rd := bufio.NewReader(conn)
  for {
    _, err := rd.Read(p)
    if err == nil {
      fmt.Printf("SERVER : %s\n", p)
    } else {
        fmt.Printf("Some error %v\n", err)
    }
  }
}

func main() {
    p :=  make([]byte, 2048)
    conn, err := net.Dial("udp", "127.0.0.1:1234")
    if err != nil {
        fmt.Printf("Some error %v", err)
        return
    }

    go xyz(conn, p)
    fmt.Fprintf(conn, "Give me a hash to work on ...")
}

server.go

package main
import (
    "fmt"
    "net"
)


func sendResponse(conn *net.UDPConn, addr *net.UDPAddr, hash string) {
    _,err := conn.WriteToUDP([]byte("Hello, here is the hash  - " + hash), addr)
    if err != nil {
        fmt.Printf("Couldn't send response %v", err)
    }
}


func main() {
    hash := "36";
    p := make([]byte, 2048)
    addr := net.UDPAddr{
        Port: 1234,
        IP: net.ParseIP("127.0.0.1"),
    }
    ser, err := net.ListenUDP("udp", &addr)
    if err != nil {
        fmt.Printf("Some error %v\n", err)
        return
    }
    for {
        _, remoteaddr, err := ser.ReadFromUDP(p)
        fmt.Printf("CLIENT : %v : %s\n", remoteaddr, p)
        if err !=  nil {
            fmt.Printf("Some error  %v", err)
            continue
        }
        go sendResponse(ser, remoteaddr, hash)
    }
}

> The Go Programming Language Specification
>
> Go statements
>
> A "go" statement starts the execution of a function call as an
> independent concurrent thread of control, or goroutine, within the
> same address space.
>
> ... unlike with a regular call, program execution does not wait for
> the invoked function to complete.

client.go starts the goroutine xyz and then keeps going to the end of the main function which terminates the program. The program doesn't wait for the xyz goroutine to run or finish.