fasthttp

fasthttp is designed for high performance by minimizing memory allocations, which leads to several key differences from the standard net/http package:

• Object Reuse: Unlike net/http, which creates new request/response objects per request, fasthttp reuses existing objects to reduce GC pressure.
• Data Types: fasthttp prefers []byte over string to avoid the memory allocation and copying required for []byte to string conversion. If you need strings, you can wrap results in string(), but be aware of the overhead.
• Header Storage: fasthttp avoids the map[string][]string structure used by net/http to prevent unnecessary parsing and allocations.
• Body Handling: fasthttp buffers bodies by default. To prevent untrusted clients from consuming too much memory, use MaxResponseBodySize to bound response sizes. Note that net/http supports streaming by default, whereas fasthttp requires explicit configuration for streaming.
• API Stability: net/http has a stable API and handles more HTTP corner cases, while fasthttp is optimized for speed and its API evolves more frequently.

CRITICAL: Do not hold references to RequestCtx

fasthttp disallows holding references to *fasthttp.RequestCtx or any of its members after the RequestHandler has returned. Doing so will cause inevitable data races because the context is reused for subsequent requests.

Mitigation Strategies

1. Use TimeoutError: If you must retain references to RequestCtx or its members (e.g., for asynchronous processing), call ctx.TimeoutError() before returning from the RequestHandler.
2. Use TimeoutHandler: Wrap your RequestHandler in fasthttp.TimeoutHandler to manage request lifecycles safely.
3. Race Detector: Always use the Go race detector (go test -race or go run -race) to identify potential leaks or improper usage of the context.

func main() {
  fasthttp.ListenAndServe(":8080", fasthttp.TimeoutHandler(func(ctx *fasthttp.RequestCtx) {
    select {
    case <-ctx.Done():
      // ctx.Done() is only closed when the server is shutting down.
      log.Println("context cancelled")
      return
    case <-time.After(10 * time.Second):
      log.Println("process finished ok")
    }
  }, time.Second*2, "timeout"))
}

Follow these patterns to simplify code and improve performance when handling byte slices:

• Omit Nil Checks: Standard Go functions like append, copy, len, and range work correctly with nil buffers. You can safely remove redundant if buf != nil checks.
• Append Strings to Bytes: You can append a string directly to a []byte using append(dst, "string"...).
• Extend Capacity: You can extend a slice up to its existing capacity using slicing (e.g., buf[:100] if cap(buf) is 100).
• Nil-friendly API: Most fasthttp functions (like fasthttp.Get or fasthttp.AppendUint) accept nil as a buffer argument.

// Example: Safe use of nil buffers
var src []byte
srcLen := len(src) // Works even if src is nil

// Example: Appending string to byte slice
dst = append(dst, "foobar"...)

// Example: fasthttp accepting nil
statusCode, body, err := fasthttp.Get(nil, "http://google.com/")

fasthttp does not provide an API identical to Go's standard net/http. While a fasthttpadaptor exists to convert net/http handlers, it is recommended to write native fasthttp handlers manually to fully leverage the library's performance advantages.

Key Differences

• Handler Type: fasthttp uses RequestHandler functions instead of the http.Handler interface. You can pass bound struct methods to fasthttp.ListenAndServe to maintain state.
• Request Context: The RequestHandler accepts a single argument, *fasthttp.RequestCtx, which encapsulates all request and response functionality.
• Response Ordering: Unlike net/http, fasthttp allows you to set headers, status codes, and write the body in any order. The response is not sent to the wire until the RequestHandler returns.
• Routing: fasthttp does not include a built-in ServeMux. Instead, developers typically use third-party routers like fasthttp-routing, router, or high-level frameworks like Fiber or atreugo.

type MyHandler struct {
	foobar string
}

// request handler in net/http style, i.e. method bound to MyHandler struct.
func (h *MyHandler) HandleFastHTTP(ctx *fasthttp.RequestCtx) {
	fmt.Fprintf(ctx, "Hello, world! Requested path is %q. Foobar is %q",
		ctx.Path(), h.foobar)
}

myHandler := &MyHandler{
	foobar: "foobar",
}
fasthttp.ListenAndServe(":8080", myHandler.HandleFastHTTP)