为什么net.Dial在接受连接之前不阻塞？

Why Dial doesn't block until the connection is accepted? Or is there any way that I can detect that the connection was not accepted so that I can avoid draining my server resources? If I try to read the connection I get blocked forever (as the connection was not accepted) and I might loose the opportunity to connect/dial with the server when it decides to accept my connection too. If I launch new go routines to read from each connection returned by Dial the server gets exhausted (i.e. it can't handle thousands of go routines per second).

package main

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

func main() {
    go listen()
    // wait the listener
    time.Sleep(1)
    dial()
}
func listen() {
    dstNet := &net.TCPAddr{IP: net.ParseIP("0.0.0.0"), Port: 9090}
    // Listen on the dstNet
    _, err := net.ListenTCP("tcp", dstNet)
    if err != nil {
        panic(err)
    }
    time.Sleep(30 * time.Second)
}
func dial() {
    dstNet := &net.TCPAddr{IP: net.ParseIP("127.0.0.1"), Port: 9090}
    for {
        log.Printf("dialing")
        conn, err := net.DialTCP("tcp", nil, dstNet)
        if err != nil {
            panic(err)
            //return
        }
        log.Printf("new conn %v", conn)
    }
}

//Reason why I need dial to block call:

I'm trying to implement a reverse socks server:

server x behind NAT connects to -> server y internet

client z from internet connects to -> server y

so the issue is that the server behind NAT gets a lot of connections(due non-blocking Dial) even if server y didn't accept any.