codesnips
go 35 lines · 1 tab

Graceful shutdown: draining HTTP + background workers

Leah Thompson Jan 2026
1 tab 
package main

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

func main() {
  srv := &http.Server{Addr: ":8080", Handler: http.DefaultServeMux}

  var wg sync.WaitGroup
  wg.Add(1)
  go func() {
    defer wg.Done()
    if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
      log.Fatalf("listen: %v", err)
    }
  }()

  sigCh := make(chan os.Signal, 1)
  signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
  <-sigCh

  ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
  defer cancel()

  _ = srv.Shutdown(ctx)
  wg.Wait()
}
1 file · go Explain with highlit

A clean shutdown is part of reliability, not an afterthought. The pattern I like is: (1) start servers and workers, (2) listen for SIGINT/SIGTERM, (3) call Shutdown with a deadline, and (4) wait for background goroutines to finish. http.Server.Shutdown stops accepting new connections and drains in-flight requests, but only if your handlers respect context cancellation. I also prefer a single context.WithCancel that gets triggered by the signal, and then each subsystem gets a derived timeout. This avoids hung deployments where pods never terminate, and it prevents partial work from being abandoned without a chance to finish or roll back.

Related snips

go 
package api

import (
  "net/http"
  "runtime/debug"
)

Expose build metadata for debugging deploys

go observability build
by Leah Thompson 1 tab
typescript 
export interface RetryOptions {
  retries: number;
  baseMs: number;
  maxMs: number;
  signal?: AbortSignal;
  onRetry?: (attempt: number, delay: number, err: unknown) => void;

Exponential backoff with jitter for retries

typescript reliability retry
by codesnips 2 tabs
go 
package dbutil

import (
  "context"

  "github.com/jackc/pgconn"

Retry Postgres serialization failures with bounded attempts

go postgres transactions
by Leah Thompson 1 tab
rust 
use crossbeam::channel::unbounded;
use std::thread;

fn main() {
    let (tx, rx) = unbounded();

Crossbeam for advanced concurrent data structures

rust concurrency lock-free
by Marcus Chen 1 tab
javascript 
// Creating a Promise
const myPromise = new Promise((resolve, reject) => {
  const success = true;

  setTimeout(() => {
    if (success) {

Promises and async/await patterns for asynchronous JavaScript

javascript promises async-await
by Alex Chang 1 tab
rust 
use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

Channels (mpsc) for message passing between threads

rust concurrency channels
by Marcus Chen 1 tab

Share this code

Here's the card — post it anywhere.

Graceful shutdown: draining HTTP + background workers — share card
Link copied