
`net.Listen` binds a TCP address and returns a `net.Listener`. Calling `Accept` in a loop gives you a `net.Conn` for each client - a bidirectional stream you read from and write to. Handle each connection in a goroutine so the server can serve multiple clients concurrently.

<ExamplePair>
<ExampleProse>

The core loop: `Listen`, then `Accept` in a loop, then hand each `net.Conn` to a goroutine. The goroutine reads a line, echoes it back, and closes the connection.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "bufio"
    "fmt"
    "net"
    "strings"
)

func handleConn(conn net.Conn) {
    defer conn.Close()
    scanner := bufio.NewScanner(conn)
    for scanner.Scan() {
        line := scanner.Text()
        fmt.Fprintf(conn, "echo: %s\n", strings.ToUpper(line))
    }
}

func main() {
    ln, err := net.Listen("tcp", ":9000")
    if err != nil {
        panic(err)
    }
    defer ln.Close()
    fmt.Println("tcp server listening on :9000")

    for {
        conn, err := ln.Accept()
        if err != nil {
            fmt.Println("accept error:", err)
            continue
        }
        go handleConn(conn)
    }
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Set deadlines on the connection to prevent slow or stalled clients from holding a goroutine forever. `SetDeadline` applies to both reads and writes; `SetReadDeadline` and `SetWriteDeadline` set them independently.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "bufio"
    "fmt"
    "net"
    "time"
)

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

    // Extend the deadline on each successful read so active clients never time out
    scanner := bufio.NewScanner(conn)
    for scanner.Scan() {
        conn.SetDeadline(time.Now().Add(30 * time.Second))
        line := scanner.Text()
        fmt.Fprintf(conn, "received: %s\n", line)
    }
    if err := scanner.Err(); err != nil {
        fmt.Println("read error:", err)
    }
}

func main() {
    ln, err := net.Listen("tcp", ":9000")
    if err != nil {
        panic(err)
    }
    defer ln.Close()

    for {
        conn, err := ln.Accept()
        if err != nil {
            continue
        }
        // Set an initial deadline before the first read
        conn.SetDeadline(time.Now().Add(30 * time.Second))
        go handleConn(conn)
    }
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Raw TCP servers underpin database drivers, message queues, and custom protocols (Redis, Memcached, NATS). Always handle each accepted connection in a goroutine - a blocking `handleConn` on the accept goroutine would serialize all clients. Set `SetReadDeadline` and `SetWriteDeadline` to prevent a slow or stalled client from holding a goroutine and its stack indefinitely; without deadlines, a client that opens a connection and never sends data occupies a goroutine for the lifetime of the process. For production servers, bound the total number of concurrent connections with a semaphore (a buffered channel of capacity N) - unbounded goroutine creation from untrusted input is a denial-of-service vector. For graceful shutdown, stop calling `Accept` (close the listener) and wait for active `handleConn` goroutines to drain using a `sync.WaitGroup`. If your protocol is line-oriented, `bufio.Scanner` is convenient; for binary protocols with length-prefixed frames, use `encoding/binary` with `io.ReadFull` to read exactly N bytes at a time.
</InProduction>


net.Listen + Accept in a loop; handle each net.Conn in a goroutine and set deadlines - without them a stalled client holds a goroutine open for the process lifetime.

TCP Server


`context.Context` carries a cancellation signal, a deadline, and optional key-value metadata through a call stack. Pass it as the first argument to any function that does I/O or calls an external service - the convention is enforced by linters and expected by the entire stdlib.

<ExamplePair>
<ExampleProse>

`context.WithCancel` returns a derived context and a cancel function. Calling cancel broadcasts the cancellation to every goroutine holding the context. Always call cancel - if you forget, the parent context leaks the child until the parent itself is cancelled.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "context"
    "fmt"
    "time"
)

func doWork(ctx context.Context, id int) {
    for {
        select {
        case <-ctx.Done():
            fmt.Printf("worker %d stopped: %v\n", id, ctx.Err())
            return
        case <-time.After(200 * time.Millisecond):
            fmt.Printf("worker %d tick\n", id)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()

    go doWork(ctx, 1)
    go doWork(ctx, 2)

    time.Sleep(600 * time.Millisecond)
    cancel()
    time.Sleep(100 * time.Millisecond)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`context.WithTimeout` cancels the context automatically after the duration. `context.WithDeadline` does the same with an absolute time. Both return a cancel function - call it with `defer` to release resources when the operation finishes before the deadline.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "context"
    "fmt"
    "time"
)

func fetchData(ctx context.Context) (string, error) {
    // Simulate a slow operation
    select {
    case <-time.After(2 * time.Second):
        return "data", nil
    case <-ctx.Done():
        return "", ctx.Err()
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 500*time.Millisecond)
    defer cancel()

    result, err := fetchData(ctx)
    if err != nil {
        fmt.Println("error:", err) // context deadline exceeded
        return
    }
    fmt.Println("result:", result)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`context.WithValue` attaches request-scoped metadata. Use a private key type to avoid collisions across packages. Retrieve values with `ctx.Value(key)` and assert the type.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "context"
    "fmt"
)

type contextKey string

const traceIDKey contextKey = "traceID"

func handleRequest(ctx context.Context) {
    traceID, ok := ctx.Value(traceIDKey).(string)
    if !ok {
        fmt.Println("no trace ID in context")
        return
    }
    fmt.Println("handling request with trace ID:", traceID)
}

func main() {
    ctx := context.WithValue(context.Background(), traceIDKey, "abc-123")
    handleRequest(ctx)
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Always accept `context.Context` as the first parameter of functions that do I/O or call external services - the convention is so universal that `go vet` flags violations. Never store a context in a struct field; contexts are request-scoped and must flow through the call stack, not be held across requests. Use `context.WithTimeout` for outbound HTTP calls, database queries, and gRPC calls - the zero-timeout default in `net/http` has caused countless production incidents where a slow downstream service held goroutines open indefinitely. Check `ctx.Done()` in long-running loops so cancellation is propagated promptly rather than only at the next I/O boundary. `context.WithValue` is for request-scoped metadata (trace IDs, auth info, request IDs) only - it is not a mechanism for passing optional function parameters, which belong in function signatures. Use a private unexported key type (a named `type contextKey string`) to avoid key collisions between packages that share a context.
</InProduction>


context.WithCancel / WithTimeout / WithDeadline propagate cancellation and deadlines through the call stack - pass context as the first argument to any function that does I/O.

Context


`http.ListenAndServe` starts an HTTP server using the package-level default mux and a zero-value server with no timeouts. For production use, construct `http.Server` explicitly so you control timeouts and can implement graceful shutdown.

<ExamplePair>
<ExampleProse>

Register handlers with `http.HandleFunc` (pattern, handler) or create a custom `http.ServeMux`. Go 1.22 added method and path-parameter syntax (`GET /users/{id}`) to the standard mux.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "fmt"
    "net/http"
)

func main() {
    mux := http.NewServeMux()

    mux.HandleFunc("GET /", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "hello, world")
    })

    // Go 1.22 path parameters: {id} is captured in r.PathValue("id")
    mux.HandleFunc("GET /users/{id}", func(w http.ResponseWriter, r *http.Request) {
        id := r.PathValue("id")
        fmt.Fprintf(w, "user: %s\n", id)
    })

    mux.HandleFunc("POST /users", func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusCreated)
        fmt.Fprintln(w, "created")
    })

    http.ListenAndServe(":8080", mux)
}
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Construct `http.Server` explicitly to set timeouts, then implement graceful shutdown by listening for OS signals and calling `server.Shutdown`. In-flight requests are allowed to complete before the server stops accepting new connections.

</ExampleProse>
<ExampleCode>

```go
package main

import (
    "context"
    "fmt"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("GET /health", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintln(w, "ok")
    })

    server := &http.Server{
        Addr:         ":8080",
        Handler:      mux,
        ReadTimeout:  5 * time.Second,
        WriteTimeout: 10 * time.Second,
        IdleTimeout:  120 * time.Second,
    }

    // Start serving in a goroutine
    go func() {
        fmt.Println("listening on :8080")
        if err := server.ListenAndServe(); err != http.ErrServerClosed {
            fmt.Fprintf(os.Stderr, "server error: %v\n", err)
            os.Exit(1)
        }
    }()

    // Block until SIGINT or SIGTERM
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit

    // Give in-flight requests up to 30s to complete
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    if err := server.Shutdown(ctx); err != nil {
        fmt.Fprintf(os.Stderr, "shutdown error: %v\n", err)
    }
    fmt.Println("server stopped")
}
```

</ExampleCode>
</ExamplePair>

<InProduction>
Always use `http.Server` explicitly rather than `http.ListenAndServe` - the convenience function creates a zero-value server with no timeouts, which is vulnerable to slowloris attacks (a client sends headers one byte per second, holding the connection open indefinitely) and connection exhaustion. Set `ReadTimeout` to limit how long the server waits for a complete request, `WriteTimeout` to limit the response write phase, and `IdleTimeout` to reclaim keep-alive connections from idle clients. For graceful shutdown, call `server.Shutdown(ctx)` in response to `SIGTERM` - Kubernetes sends `SIGTERM` before `SIGKILL` and waits `terminationGracePeriodSeconds` (default 30s). `Shutdown` stops accepting new connections, waits for active handlers to return, then closes the listener - returning `nil` on success. If handlers block indefinitely (missing context propagation), `Shutdown` will wait until the context deadline fires and then return an error, so make sure every handler respects context cancellation on slow paths.
</InProduction>


Use http.Server explicitly with ReadTimeout, WriteTimeout, and IdleTimeout - the zero-value server has no timeouts and is vulnerable to slowloris and connection exhaustion.