# Go-Interview: Goroutines, Channels und Concurrency-Patterns meistern

> Go-Interviewfragen zu Goroutines, Channels und Concurrency mit Codebeispielen. Fan-Out/Fan-In, Worker Pools, Race Conditions und Context-Patterns.

- Published: 2026-04-01
- Updated: 2026-04-01
- Author: Anthony Fillion-Maillet
- Tags: go, interview, concurrency, goroutines, channels
- Reading time: 12 min

---

Go-Interviewfragen zu Goroutinen, Channels und Concurrency gehören zu den anspruchsvollsten Themen, mit denen sich Kandidaten in technischen Vorstellungsgesprächen auseinandersetzen müssen. Ein fundiertes Verständnis dieser Konzepte unterscheidet erfahrene Go-Entwickler von Einsteigern. Dieser Leitfaden deckt die konkreten Fragen ab, die Interviewer 2026 stellen, mit produktionsreifen Codebeispielen und den Erklärungen hinter jeder Antwort.

> **Was Interviewer tatsächlich prüfen**
>
> Go-Concurrency-Interviews konzentrieren sich auf drei Bereiche: Goroutine-Lifecycle-Management, Channel-Semantik (gepuffert vs. ungepuffert, direktionale Typen) und Pattern-Komposition (Fan-Out/Fan-In, Worker Pools, Context-Cancellation). Syntax auswendig zu lernen reicht nicht aus — Interviewer erwarten, dass Kandidaten über Race Conditions und Deadlocks argumentieren können.

## Goroutine-Grundlagen: Was jeder Interviewer fragt

Die erste Runde an Fragen prüft typischerweise, ob der Kandidat versteht, was Goroutinen tatsächlich sind — nicht nur, wie man sie startet.

**F: Was ist eine Goroutine, und wie unterscheidet sie sich von einem OS-Thread?**

Eine Goroutine ist eine leichtgewichtige, nebenläufige Funktion, die vom Go-Runtime-Scheduler verwaltet wird — nicht vom Betriebssystem. Die Go-Runtime multiplext Tausende von Goroutinen auf eine kleine Anzahl von OS-Threads mithilfe eines M:N-Scheduling-Modells (M Goroutinen werden auf N OS-Threads abgebildet).

```go
// goroutine_basics.go
package main

import (
	"fmt"
	"runtime"
	"sync"
)

func main() {
	// Print the number of OS threads available
	fmt.Println("GOMAXPROCS:", runtime.GOMAXPROCS(0))

	var wg sync.WaitGroup

	for i := 0; i < 10000; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			// Each goroutine starts with ~2-8KB stack
			// OS threads typically start with 1-8MB
			_ = id
		}(i)
	}

	wg.Wait()
	fmt.Println("All 10,000 goroutines completed")
}
```

Wesentliche Unterschiede, die im Interview zur Sprache kommen sollten: Goroutinen starten mit einem 2-8 KB großen Stack, der dynamisch wächst, im Gegensatz zum festen 1-8 MB Stack eines OS-Threads. Kontextwechsel zwischen Goroutinen erfolgen im User Space durch den Go-Scheduler, wodurch die aufwändigen Kernel-Level-Kontextwechsel von OS-Threads vermieden werden. Das macht es praktikabel, 100.000 Goroutinen zu starten, während 100.000 OS-Threads die Systemressourcen erschöpfen würden.

**F: Was passiert, wenn eine Goroutine in Panik gerät?**

Ein nicht abgefangener Panic in einer beliebigen Goroutine bringt das gesamte Programm zum Absturz. Anders als Exceptions in Java oder Python propagiert ein Panic nur den eigenen Call-Stack der Goroutine nach oben — nicht den Stack der Goroutine, die sie gestartet hat. Die einzige Möglichkeit, ihn abzufangen, ist `recover()` innerhalb einer deferred Funktion in derselben Goroutine.

```go
// panic_recovery.go
package main

import "fmt"

func safeGo(fn func()) {
	go func() {
		defer func() {
			if r := recover(); r != nil {
				fmt.Println("recovered from panic:", r)
			}
		}()
		fn() // execute the actual work
	}()
}

func main() {
	safeGo(func() {
		panic("something went wrong")
	})

	// Give goroutine time to complete
	select {}
}
```

Interviewer achten darauf, ob der Kandidat weiß, dass produktive Go-Services Goroutine-Starts in ein Recovery-Pattern einbetten. Bibliotheken wie `errgroup` lösen dieses Problem eleganter.

## Channel-Semantik: Gepuffert, ungepuffert und direktional

Channel-Fragen zeigen, ob ein Kandidat das Concurrency-Modell von Go wirklich versteht oder nur Patterns auswendig gelernt hat.

**F: Was ist der Unterschied zwischen einem gepufferten und einem ungepufferten Channel?**

Ein ungepufferter Channel (`make(chan T)`) erfordert, dass Sender und Empfänger gleichzeitig bereit sind — das Senden blockiert, bis eine andere Goroutine empfängt. Ein gepufferter Channel (`make(chan T, n)`) erlaubt das Senden von bis zu `n` Werten ohne Blockierung.

```go
// channel_semantics.go
package main

import "fmt"

func main() {
	// Unbuffered: send blocks until receive is ready
	ch := make(chan string)
	go func() {
		ch <- "hello" // blocks here until main reads
	}()
	msg := <-ch
	fmt.Println(msg)

	// Buffered: send does not block until buffer is full
	buf := make(chan int, 3)
	buf <- 1 // does not block (buffer has space)
	buf <- 2 // does not block
	buf <- 3 // does not block
	// buf <- 4 would block — buffer is full

	fmt.Println(<-buf, <-buf, <-buf) // 1 2 3
}
```

Die häufige Nachfrage lautet: "Wann würde man welchen Typ verwenden?" Ungepufferte Channels erzwingen Synchronisation — sinnvoll, wenn der Sender sicher sein muss, dass der Empfänger den Wert verarbeitet hat. Gepufferte Channels entkoppeln das Timing von Sender und Empfänger — geeignet für Arbeitsqueues oder Rate Limiting, bei dem eine gewisse Entkopplung akzeptabel ist.

**F: Was passiert, wenn man einen Channel schließt?**

Das Schließen eines Channels signalisiert, dass keine weiteren Werte gesendet werden. Empfangsoperationen auf einem geschlossenen Channel geben sofort den Nullwert zurück. Das Senden auf einem geschlossenen Channel löst einen Panic aus. Eine `range`-Schleife über einen Channel endet automatisch, wenn der Channel geschlossen wird.

```go
// close_channel.go
package main

import "fmt"

func producer(ch chan<- int, count int) {
	for i := 0; i < count; i++ {
		ch <- i
	}
	close(ch) // signal: no more values
}

func main() {
	ch := make(chan int, 5)
	go producer(ch, 5)

	// range exits automatically when channel closes
	for val := range ch {
		fmt.Println("received:", val)
	}

	// Reading from closed channel returns zero value + false
	val, ok := <-ch
	fmt.Printf("after close: val=%d, ok=%v\n", val, ok)
}
```

Ein entscheidender Punkt: Nur der Sender sollte einen Channel schließen, niemals der Empfänger. Das Schließen eines Channels, in den eine andere Goroutine noch schreibt, verursacht einen Panic.

## Die Select-Anweisung: Channel-Multiplexing

**F: Wie funktioniert `select`, und was passiert, wenn mehrere Cases gleichzeitig bereit sind?**

Die `select`-Anweisung blockiert, bis eine ihrer Channel-Operationen fortfahren kann. Wenn mehrere Cases gleichzeitig bereit sind, wählt Go zufällig einen aus — das verhindert, dass ein bestimmter Case dauerhaft benachteiligt wird (Starvation).

```go
// select_multiplex.go
package main

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

func fetchFromAPI(ctx context.Context, url string) (string, error) {
	resultCh := make(chan string, 1)
	errCh := make(chan error, 1)

	go func() {
		// Simulate API call
		time.Sleep(200 * time.Millisecond)
		resultCh <- fmt.Sprintf("data from %s", url)
	}()

	select {
	case result := <-resultCh:
		return result, nil
	case err := <-errCh:
		return "", err
	case <-ctx.Done():
		// Context cancelled or timed out
		return "", ctx.Err()
	}
}

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

	result, err := fetchFromAPI(ctx, "https://api.example.com/data")
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(result)
}
```

Interviewer prüfen mit `select` zwei Dinge: das Verständnis der zufälligen Auswahlregel und die Fähigkeit, Channels mit `context.Context` für Timeout- und Cancellation-Patterns zu kombinieren.

## Concurrency-Patterns: Die häufigsten Interview-Aufgaben

In Senior-Level-Go-Interviews wird fast immer erwartet, eines dieser Patterns von Grund auf zu implementieren.

### Fan-Out/Fan-In-Pattern

**F: Implementiere eine Fan-Out/Fan-In-Pipeline, die Elemente nebenläufig verarbeitet.**

Fan-Out verteilt Arbeit auf mehrere Goroutinen. Fan-In sammelt Ergebnisse aus mehreren Goroutinen in einem einzigen Channel.

```go
// fanout_fanin.go
package main

import (
	"fmt"
	"sync"
)

// generator produces values on a channel
func generator(nums ...int) <-chan int {
	out := make(chan int)
	go func() {
		for _, n := range nums {
			out <- n
		}
		close(out)
	}()
	return out
}

// square reads from input, squares each value
func square(in <-chan int) <-chan int {
	out := make(chan int)
	go func() {
		for n := range in {
			out <- n * n
		}
		close(out)
	}()
	return out
}

// fanIn merges multiple channels into one
func fanIn(channels ...<-chan int) <-chan int {
	var wg sync.WaitGroup
	merged := make(chan int)

	for _, ch := range channels {
		wg.Add(1)
		go func(c <-chan int) {
			defer wg.Done()
			for val := range c {
				merged <- val
			}
		}(ch)
	}

	go func() {
		wg.Wait()
		close(merged) // close after all inputs are drained
	}()

	return merged
}

func main() {
	in := generator(2, 3, 4, 5, 6)

	// Fan out: two goroutines reading from same channel
	c1 := square(in)
	c2 := square(in)

	// Fan in: merge results
	for result := range fanIn(c1, c2) {
		fmt.Println(result)
	}
}
```

Die zentrale Erkenntnis, die Interviewer erwarten: Der `generator`-Channel wird zwischen `c1` und `c2` geteilt, sodass jeder Wert von genau einem Worker verarbeitet wird (keine Duplizierung). Die `fanIn`-Funktion verwendet eine `WaitGroup`, um zu wissen, wann alle Eingangs-Channels leer sind, bevor der zusammengeführte Channel geschlossen wird.

### Worker Pool mit errgroup

**F: Wie würde man einen begrenzten Worker Pool mit Fehlerbehandlung implementieren?**

Das Paket `golang.org/x/sync/errgroup` (Teil der erweiterten Go-Standardbibliothek) löst dieses Problem sauber. Es verwaltet Goroutine-Lebenszyklen, sammelt den ersten Fehler und integriert sich mit `context` für Cancellation.

```go
// worker_pool.go
package main

import (
	"context"
	"fmt"
	"golang.org/x/sync/errgroup"
)

func processItem(ctx context.Context, id int) error {
	// Check for cancellation before heavy work
	select {
	case <-ctx.Done():
		return ctx.Err()
	default:
	}

	if id == 7 {
		return fmt.Errorf("failed to process item %d", id)
	}
	fmt.Printf("processed item %d\n", id)
	return nil
}

func main() {
	g, ctx := errgroup.WithContext(context.Background())
	g.SetLimit(3) // maximum 3 concurrent goroutines

	for i := 0; i < 10; i++ {
		id := i
		g.Go(func() error {
			return processItem(ctx, id)
		})
	}

	// Wait blocks until all goroutines finish
	// Returns the first non-nil error
	if err := g.Wait(); err != nil {
		fmt.Println("pipeline error:", err)
	}
}
```

Seit Go 1.24 (dem aktuellen stabilen Release Anfang 2026) bleibt dieses Pattern der empfohlene Ansatz. Die `SetLimit`-Methode wurde in Go 1.20 eingeführt und macht die manuelle Implementierung von Semaphor-basierter Concurrency-Begrenzung überflüssig.

## Race Conditions und sync-Primitive

**F: Wie erkennt und verhindert man Race Conditions in Go?**

Go bietet einen eingebauten Race Detector, der mit dem `-race`-Flag aktiviert wird. Er erkennt nicht synchronisierten nebenläufigen Zugriff auf gemeinsamen Speicher zur Laufzeit.

```go
// race_condition.go
package main

import (
	"fmt"
	"sync"
	"sync/atomic"
)

// BAD: race condition — do not use in production
func unsafeCounter() int {
	counter := 0
	var wg sync.WaitGroup
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			counter++ // DATA RACE: concurrent read/write
		}()
	}
	wg.Wait()
	return counter // result is non-deterministic
}

// GOOD: atomic operations for simple counters
func atomicCounter() int64 {
	var counter atomic.Int64
	var wg sync.WaitGroup
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			counter.Add(1) // thread-safe atomic increment
		}()
	}
	wg.Wait()
	return counter.Load() // always 1000
}

// GOOD: mutex for complex shared state
type SafeMap struct {
	mu sync.RWMutex
	data map[string]int
}

func (m *SafeMap) Set(key string, val int) {
	m.mu.Lock()         // exclusive lock for writes
	defer m.mu.Unlock()
	m.data[key] = val
}

func (m *SafeMap) Get(key string) (int, bool) {
	m.mu.RLock()         // shared lock for reads
	defer m.mu.RUnlock()
	v, ok := m.data[key]
	return v, ok
}

func main() {
	fmt.Println("unsafe:", unsafeCounter())  // unpredictable
	fmt.Println("atomic:", atomicCounter())  // always 1000
}
```

Die Interview-Antwort sollte drei Synchronisationsstrategien abdecken: `sync.Mutex` / `sync.RWMutex` für komplexen gemeinsamen Zustand, `sync/atomic` für einfache Zähler und Flags sowie Channels für die Kommunikation zwischen Goroutinen ("Share memory by communicating, don't communicate by sharing memory"). Die Ausführung von `go test -race ./...` sollte fester Bestandteil jeder CI-Pipeline sein.

## Context und Cancellation-Patterns

**F: Wie steuert context.Context den Lebenszyklus von Goroutinen?**

Das `context`-Paket bietet einen Mechanismus zur Weitergabe von Cancellation-Signalen, Deadlines und Request-spezifischen Werten über Goroutine-Grenzen hinweg. Jede langlebige Goroutine sollte einen `context.Context` als ersten Parameter akzeptieren.

```go
// context_cancellation.go
package main

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

// worker simulates a long-running task
func worker(ctx context.Context, id int, results chan<- string) {
	select {
	case <-time.After(time.Duration(id*100) * time.Millisecond):
		results <- fmt.Sprintf("worker %d: done", id)
	case <-ctx.Done():
		results <- fmt.Sprintf("worker %d: cancelled (%v)", id, ctx.Err())
	}
}

func main() {
	// Parent context with 250ms deadline
	ctx, cancel := context.WithTimeout(context.Background(), 250*time.Millisecond)
	defer cancel()

	results := make(chan string, 5)

	// Launch 5 workers with increasing durations
	for i := 1; i <= 5; i++ {
		go worker(ctx, i, results)
	}

	// Collect all results
	for i := 0; i < 5; i++ {
		fmt.Println(<-results)
	}
}
```

Worker 1 und 2 werden innerhalb der 250-ms-Deadline fertig. Worker 3, 4 und 5 erhalten das Cancellation-Signal über `ctx.Done()`. Dieses Pattern ist grundlegend für den Bau robuster HTTP-Server und Microservices in Go — jeder Request-Handler empfängt einen Context, der die Cancellation weitergibt, wenn sich der Client trennt.

> **Häufige Interview-Falle**
>
> Einen `context.Context` sollte man niemals in einem Struct-Feld speichern. Die [offizielle Go-Dokumentation](https://pkg.go.dev/context) sagt ausdrücklich: "Do not store Contexts inside a struct type; instead, pass a Context explicitly to each function that needs it." Interviewer prüfen damit, ob der Kandidat Go-Konventionen befolgt.

## Deadlock-Erkennung: Knifflige Interview-Fragen

**F: Wird dieser Code einen Deadlock verursachen? Warum?**

Deadlock-Fragen sind beliebt, weil sie die Fähigkeit des Kandidaten prüfen, über Goroutine-Scheduling und Channel-Operationen zu argumentieren.

```go
// deadlock_example.go
package main

func main() {
	ch := make(chan int)
	ch <- 42 // DEADLOCK: unbuffered send with no receiver
	// The main goroutine blocks here forever
	// Go runtime detects this: "fatal error: all goroutines are asleep"
}
```

Die Lösung ist einfach: Entweder den Channel gepuffert machen (`make(chan int, 1)`) oder eine Goroutine starten, die vor dem Senden empfängt. Die Go-Runtime erkennt Deadlocks, wenn alle Goroutinen blockiert sind — aber nur, wenn *alle* Goroutinen schlafen. Läuft auch nur eine Goroutine (z. B. ein HTTP-Server im Hintergrund), erkennt die Runtime einen partiellen Deadlock nicht.

> **Partielle Deadlocks bleiben unsichtbar**
>
> Die Go-Runtime erkennt Deadlocks nur, wenn jede Goroutine im Programm blockiert ist. In realen Anwendungen mit HTTP-Servern oder Hintergrund-Workern werden Goroutine-Leaks mit Deadlocks den Runtime-Detektor nicht auslösen. Werkzeuge wie `pprof` und Goroutine-Dumps (`runtime.Stack`) sind notwendig, um solche Probleme in der Produktion zu diagnostizieren.

## Rate-Limited Concurrent Processing: Fortgeschrittenes Pattern

**F: Wie würde man ratenbegrenzte, nebenläufige API-Aufrufe implementieren?**

Diese Frage prüft die Fähigkeit, mehrere Concurrency-Primitive zu einer schlüssigen Lösung zu kombinieren.

```go
// rate_limited.go
package main

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

// RateLimiter controls concurrent and temporal access
type RateLimiter struct {
	semaphore chan struct{}   // limits concurrency
	ticker    *time.Ticker    // limits rate
}

func NewRateLimiter(maxConcurrent int, interval time.Duration) *RateLimiter {
	return &RateLimiter{
		semaphore: make(chan struct{}, maxConcurrent),
		ticker:    time.NewTicker(interval),
	}
}

func (rl *RateLimiter) Execute(ctx context.Context, fn func() error) error {
	// Wait for rate limit tick
	select {
	case <-rl.ticker.C:
	case <-ctx.Done():
		return ctx.Err()
	}

	// Acquire concurrency slot
	select {
	case rl.semaphore <- struct{}{}:
	case <-ctx.Done():
		return ctx.Err()
	}

	defer func() { <-rl.semaphore }() // release slot
	return fn()
}

func main() {
	rl := NewRateLimiter(3, 100*time.Millisecond)
	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
	defer cancel()

	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			err := rl.Execute(ctx, func() error {
				fmt.Printf("[%v] processing %d\n", time.Now().Format("04:05.000"), id)
				time.Sleep(150 * time.Millisecond) // simulate work
				return nil
			})
			if err != nil {
				fmt.Printf("item %d: %v\n", id, err)
			}
		}(i)
	}
	wg.Wait()
}
```

Dieses Pattern kombiniert einen Channel-basierten Semaphor (für Concurrency-Begrenzung) mit einem Ticker (für Rate Limiting). Das doppelte `select` mit Context-Prüfung stellt einen sauberen Shutdown sicher. Genau diese Art produktionsreifer Antworten unterscheidet Senior-Kandidaten von anderen Bewerbern.

## Fazit

- Goroutinen sind User-Space-Threads, die von der Go-Runtime mit M:N-Scheduling verwaltet werden; Panics in gestarteten Goroutinen müssen immer abgefangen werden
- Ungepufferte Channels synchronisieren Sender und Empfänger; gepufferte Channels entkoppeln das Timing — die Wahl hängt davon ab, ob der Sender eine Bestätigung benötigt
- Die `select`-Anweisung multiplext Channel-Operationen mit zufälliger Auswahl, wenn mehrere bereit sind; in Kombination mit `context.Context` entstehen Timeout-Patterns
- Fan-Out/Fan-In und Worker Pools (über `errgroup.SetLimit`) sind die beiden am häufigsten gefragten Concurrency-Patterns
- `sync.Mutex` für komplexen gemeinsamen Zustand, `sync/atomic` für einfache Zähler und Channels für die Goroutine-Kommunikation verwenden
- `go test -race` sollte in jeder CI-Pipeline laufen, um Data Races zu erkennen; partielle Deadlocks erfordern `pprof` zur Diagnose
- `context.Context` niemals in Structs speichern — immer als ersten Funktionsparameter übergeben
- Rate Limiting in Go kombiniert Channel-Semaphore mit Tickern, eingebettet in kontextbewusste Select-Anweisungen

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/de/blog/go/go-technical-interview-goroutines-channels-concurrency