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



This course is not scheduled as a public course.
It is delivered exclusively as customised training. The content, duration, date, and delivery format are tailored to the customer's requirements and can also be provided in English.

Request customised training

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