Go – parallel programming (GO4)

Programming, Rust

Master Go's concurrency model and use its lightweight scheduling to write scalable parallel programs. Learn how goroutines run as cheap concurrent units, how channels safely pass data, and how the Go scheduler enables efficient parallelism across CPUs.

Practice writing concurrent programs with goroutines and message passing via channels. Use context.Context for cancellations and deadlines, apply sync primitives and patterns like worker pools and pipelines to build robust, hardware-efficient services.

THIS TRAINING COURSE WILL HELP YOU:

  • Apply goroutine, channel and scheduler idioms
  • Use context.Context for cancellation and deadlines
  • Use synchronization primitives and atomic operations
  • Design worker pools, pipelines and fan-in/fan-out
  • Build robust HTTP services with per-request context and graceful shutdown

WHO SHOULD ATTEND?

  • Go backend developers
  • DevOps and SRE operating Go services
  • System and backend architects
  • Engineers responsible for performance and tuning
  • Testers and QA working with concurrent code

COURSE LOCATION AND AVAILABLE DATES



Public courses are usually delivered in Czech, but this course is also available in English. We can arrange private training for your team online, at your premises or in our classrooms, and tailor the content to your needs.

For groups of around 4 or more participants, private training can already be comparable in price to booking individual places on a public course. Send us your requirements and we’ll recommend the best format and provide an exact quote.

Request training in English

Course content:

Hide details
  • Go concurrency model
    1. Goroutines and the scheduler: lightweight threads, GOMAXPROCS
    2. Channels: unbuffered vs buffered, data ownership and back-pressure
    3. select, timeouts, context.Context (cancel, deadline, values)
  • Synchronization primitives
    1. sync.WaitGroup, sync.Mutex/RWMutex, sync.Cond, sync.Map, sync.Pool
    2. Atomic operations (sync/atomic), memory model — practical exercises
  • Patterns and architecture
    1. Worker pool, pipeline, fan-in/fan-out, throttle
    2. Idempotence, retries, dead-letter handling, graceful shutdown
  • Concurrent I/O and HTTP services
    1. Per-request context, deadline/cancellation, rate limiting
    2. Robust server practices: shutdown, health checks, readiness
  • Testing and debugging concurrency
    1. race detector, more deterministic tests, time-based flakiness
    2. Goroutine profiling, contention hotspots, execution trace analysis
Prerequisites:
Basic proficiency in Go programming.
Recommended previous course:
Go – Generic Programming (GO3)
Recommended follow-up course:
Go – Design Patterns (GO5)
Schedule:
3 days (9:00-17:00)
Language:
Česky

Training and learning environment