Guide de Révision Go - Préparation Entretien Technique
Vous avez un entretien technique en Go et besoin de réviser rapidement ? Ce guide condensé couvre les concepts essentiels que vous devez maîtriser pour réussir votre entretien. Parfait pour une révision solo, une simulation d'entretien ou comme référence technique.
Points essentiels à retenir:
- Syntaxe de base : Variables, fonctions, structures de contrôle
- Types et structures : Slices, maps, structs, interfaces
- Concurrence : Goroutines et channels
- Gestion d'erreurs : Patterns et bonnes pratiques
- Tests et organisation : Testing, packages, modules
1. Syntaxe de base et fondamentaux
Les concepts fondamentaux que tout entretien technique Go va tester. Maîtrisez ces éléments en priorité car ils sont la base de tous les exercices pratiques.
Variables et types
Déclarations et types essentiels
// Déclarations de variables
var name string = "John"
age := 25 // Inférence de type
var count int // Valeur zéro
// Types de base
var (
str string = "hello"
num int = 42
flag bool = true
pi float64 = 3.14
)
// Constantes
const MaxUsers = 100
const (
StatusActive = iota // 0
StatusPending // 1
StatusInactive // 2
)
// Pointeurs (souvent demandé en entretien)
var p *int
x := 42
p = &x
fmt.Println(*p) // 42
Fonctions et méthodes
Patterns de fonctions courants en entretien
// Fonction basique avec retours multiples
func divide(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("division by zero")
}
return a / b, nil
}
// Fonction avec paramètres nommés (souvent demandé)
func createUser(name, email string) (id int, err error) {
if name == "" {
err = errors.New("name required")
return
}
id = generateID()
return
}
// Fonctions variadiques
func sum(numbers ...int) int {
total := 0
for _, num := range numbers {
total += num
}
return total
}
// Closures (pattern avancé)
func counter() func() int {
count := 0
return func() int {
count++
return count
}
}
Structures de contrôle
Loops et conditions spécifiques à Go
// Boucle for classique
for i := 0; i < 10; i++ {
fmt.Println(i)
}
// While équivalent
for condition {
// code
}
// Boucle infinie
for {
// code
break
}
// Range sur slice/map (très utilisé en entretien)
fruits := []string{"apple", "banana", "orange"}
for index, fruit := range fruits {
fmt.Printf("%d: %s\n", index, fruit)
}
// Range sur map
scores := map[string]int{"Alice": 95, "Bob": 87}
for name, score := range scores {
fmt.Printf("%s: %d\n", name, score)
}
// Switch spécifique à Go
switch day := time.Now().Weekday(); day {
case time.Saturday, time.Sunday:
fmt.Println("Weekend")
default:
fmt.Println("Weekday")
}
// Type switch (souvent demandé)
func checkType(v interface{}) {
switch t := v.(type) {
case string:
fmt.Printf("String: %s\n", t)
case int:
fmt.Printf("Integer: %d\n", t)
default:
fmt.Printf("Unknown type: %T\n", t)
}
}
🧠 Quiz - Syntaxe de base
- Quelle est la différence entre
var x intetx := 0?
Réponse : var peut être utilisé au niveau package, := seulement dans les fonctions. := fait de l'inférence de type. - Que se passe-t-il si on fait
var p *int; fmt.Println(*p)?
Réponse : Panic ! p est nil, on ne peut pas déréférencer un pointeur nil. - Combien de valeurs retourne cette fonction :
func test() (int, error)?
Réponse : 2 valeurs - un int et une error. Pattern classique en Go. - Dans une fonction avec retours nommés, que fait un
returnsans arguments ?
Réponse : Retourne les valeurs actuelles des variables nommées (naked return).
2. Types composés et structures
Les structures de données Go sont différentes de celles de JavaScript/TypeScript. Ces concepts sont systématiquement testés en entretien technique.
Slices - Le type le plus important
Slices : manipulation et pièges courants
// Création de slices
var slice1 []int // slice nil
slice2 := make([]int, 5) // slice de 5 éléments (zéros)
slice3 := make([]int, 5, 10) // len=5, cap=10
slice4 := []int{1, 2, 3, 4, 5} // slice literal
// Opérations essentielles (TOUJOURS demandé en entretien)
slice := []int{1, 2, 3}
slice = append(slice, 4, 5) // Ajout d'éléments
copy(slice2, slice) // Copie
// Slicing (syntaxe critique)
nums := []int{0, 1, 2, 3, 4, 5}
fmt.Println(nums[1:4]) // [1 2 3]
fmt.Println(nums[:3]) // [0 1 2]
fmt.Println(nums[2:]) // [2 3 4 5]
// PIÈGE CLASSIQUE : modification de slice
func modifySlice(s []int) {
s[0] = 999 // Modifie l'original !
}
func appendToSlice(s []int) []int {
return append(s, 6) // Peut créer un nouveau slice
}
// Fonction remove (souvent demandée)
func remove(slice []int, index int) []int {
return append(slice[:index], slice[index+1:]...)
}
Maps - Association clé-valeur
Maps : patterns et vérifications
// Création et initialisation
users := make(map[string]int)
users["alice"] = 25
users["bob"] = 30
// Map literal
scores := map[string]int{
"alice": 95,
"bob": 87,
"carol": 92,
}
// Vérification d'existence (TRÈS IMPORTANT)
score, exists := scores["alice"]
if exists {
fmt.Printf("Alice's score: %d\n", score)
}
// Pattern safe access
if score, ok := scores["dave"]; ok {
fmt.Printf("Dave's score: %d\n", score)
} else {
fmt.Println("Dave not found")
}
// Suppression
delete(scores, "bob")
// Itération
for name, score := range scores {
fmt.Printf("%s: %d\n", name, score)
}
// Map de maps (structure complexe souvent testée)
matrix := make(map[string]map[string]int)
matrix["row1"] = make(map[string]int)
matrix["row1"]["col1"] = 42
Structs et méthodes
Structs : composition et méthodes
// Définition de struct
type Person struct {
Name string
Age int
Email string
private string // non exporté (minuscule)
}
// Constructeur (pattern idiomatique)
func NewPerson(name, email string, age int) *Person {
return &Person{
Name: name,
Email: email,
Age: age,
}
}
// Méthodes avec receiver
func (p Person) String() string {
return fmt.Sprintf("%s (%d)", p.Name, p.Age)
}
// Méthode avec pointer receiver (modification)
func (p *Person) HaveBirthday() {
p.Age++
}
// Embedding (composition, pas héritage)
type Employee struct {
Person // Embedding
ID int
Salary float64
}
// L'Employee "hérite" des méthodes de Person
emp := Employee{
Person: Person{Name: "Alice", Age: 30},
ID: 1001,
Salary: 75000,
}
fmt.Println(emp.String()) // Méthode de Person
emp.HaveBirthday() // Méthode de Person
// Tags struct (utile pour JSON/DB)
type User struct {
ID int `json:"id" db:"user_id"`
Username string `json:"username" db:"username"`
Email string `json:"email" db:"email"`
}
🧠 Quiz - Types composés
- Quelle est la différence entre
[]intet[5]int?
Réponse : []int est un slice (taille dynamique), [5]int est un array (taille fixe). - Que retourne
make([]int, 3, 5)?
Réponse : Un slice de longueur 3 et capacité 5, contenant [0, 0, 0]. - Comment vérifier si une clé existe dans une map ?
Réponse :value, ok := myMap["key"]; if ok { ... } - Quelle est la différence entre un receiver par valeur et par pointeur ?
Réponse : Pointeur modifie l'original, valeur travaille sur une copie. - Comment "hériter" d'une struct en Go ?
Réponse : Embedding (composition), pas d'héritage. On embed la struct dans une autre.
3. Interfaces et polymorphisme
Les interfaces Go sont différentes des interfaces TypeScript. Elles utilisent le "duck typing" implicite et sont fondamentales pour l'architecture Go.
Interfaces : patterns et implémentations
// Interface basique
type Writer interface {
Write([]byte) (int, error)
}
// Interface avec plusieurs méthodes
type ReadWriter interface {
Reader
Writer // Composition d'interfaces
}
type Reader interface {
Read([]byte) (int, error)
}
// Implémentation implicite
type FileWriter struct {
filename string
}
func (fw FileWriter) Write(data []byte) (int, error) {
// Implémentation
return len(data), nil
}
// FileWriter implémente automatiquement Writer !
// Interface vide (accepte tout)
func describe(v interface{}) {
fmt.Printf("Type: %T, Value: %v\n", v, v)
}
// Type assertion
func processWriter(w interface{}) {
if writer, ok := w.(Writer); ok {
writer.Write([]byte("hello"))
}
}
// Interfaces courantes de la stdlib (souvent demandées)
type Stringer interface {
String() string
}
type Error interface {
Error() string
}
// Custom error type
type ValidationError struct {
Field string
Message string
}
func (ve ValidationError) Error() string {
return fmt.Sprintf("%s: %s", ve.Field, ve.Message)
}
// Interface avec generics (Go 1.18+)
type Comparable[T any] interface {
Compare(T) int
}
🧠 Quiz - Interfaces
- Comment un type implémente-t-il une interface en Go ?
Réponse : Implicitement ! Il suffit d'implémenter toutes les méthodes de l'interface. - Que représente
interface{}?
Réponse : L'interface vide qui accepte n'importe quel type (équivalent à any en Go 1.18+). - Comment faire un type assertion ?
Réponse :value, ok := myInterface.(ConcreteType) - Quelle interface faut-il implémenter pour utiliser fmt.Println sur votre type ?
Réponse : L'interface Stringer avec la méthode String() string.
4. Concurrence : Goroutines et Channels
La concurrence est LA spécificité de Go. C'est le sujet le plus important et complexe en entretien technique Go. Maîtrisez ces patterns car ils sont systématiquement testés.
Création, lancement et synchronisation basique des goroutines
Envoi, réception, channels bufferisés et non-bufferisés
Worker pools, fan-in/fan-out, timeouts
WaitGroup, Mutex, atomic operations
Goroutines et Channels : exemples d'entretien
// Goroutine basique
func sayHello() {
fmt.Println("Hello from goroutine")
}
func main() {
go sayHello() // Lance en arrière-plan
time.Sleep(1 * time.Second) // Attendre la goroutine
}
// Channel pour communication
func worker(jobs <-chan int, results chan<- int) {
for job := range jobs {
results <- job * 2 // Traitement
}
}
func runWorkers() {
jobs := make(chan int, 100)
results := make(chan int, 100)
// Lancer 3 workers
for i := 0; i < 3; i++ {
go worker(jobs, results)
}
// Envoyer du travail
for i := 1; i <= 10; i++ {
jobs <- i
}
close(jobs)
// Récupérer résultats
for i := 1; i <= 10; i++ {
result := <-results
fmt.Println("Result:", result)
}
}
// Pattern select (TRÈS IMPORTANT en entretien)
func selectExample() {
ch1 := make(chan string)
ch2 := make(chan string)
go func() {
time.Sleep(1 * time.Second)
ch1 <- "from ch1"
}()
go func() {
time.Sleep(2 * time.Second)
ch2 <- "from ch2"
}()
select {
case msg1 := <-ch1:
fmt.Println(msg1)
case msg2 := <-ch2:
fmt.Println(msg2)
case <-time.After(3 * time.Second):
fmt.Println("timeout")
}
}
// WaitGroup pour synchronisation
func waitGroupExample() {
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
fmt.Printf("Worker %d done\n", id)
}(i)
}
wg.Wait() // Attendre que tous finissent
}
// Mutex pour protection (race conditions)
type Counter struct {
mu sync.Mutex
value int
}
func (c *Counter) Increment() {
c.mu.Lock()
defer c.mu.Unlock()
c.value++
}
func (c *Counter) Value() int {
c.mu.Lock()
defer c.mu.Unlock()
return c.value
}
🧠 Quiz - Concurrence
- Quelle est la différence entre un channel bufferisé et non-bufferisé ?
Réponse : Non-bufferisé = synchrone (bloque jusqu'à réception), bufferisé = asynchrone jusqu'à saturation du buffer. - Comment éviter une goroutine leak avec un channel ?
Réponse : Toujours fermer le channel avec close() ou utiliser un context avec timeout. - Que fait select avec un default ?
Réponse : Si aucun channel n'est prêt, exécute le case default (évite le blocage). - Quand utiliser WaitGroup vs channels ?
Réponse : WaitGroup pour attendre la fin de goroutines, channels pour la communication. - Comment protéger une variable partagée entre goroutines ?
Réponse : Mutex, channels, ou atomic operations selon le cas.
5. Gestion d'erreurs et patterns
Go a une philosophie unique pour la gestion d'erreurs. Pas d'exceptions, mais des retours multiples. Cette approche est testée dans tous les entretiens.
Patterns de gestion d'erreurs Go
// Pattern de base : retour multiple
func divide(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("cannot divide by zero")
}
return a / b, nil
}
// Utilisation
result, err := divide(10, 2)
if err != nil {
log.Fatal(err)
}
fmt.Println(result)
// Custom error types
type ValidationError struct {
Field string
Value interface{}
Msg string
}
func (ve *ValidationError) Error() string {
return fmt.Sprintf("validation failed for %s: %s", ve.Field, ve.Msg)
}
// Error wrapping (Go 1.13+)
func processFile(filename string) error {
file, err := os.Open(filename)
if err != nil {
return fmt.Errorf("failed to open %s: %w", filename, err)
}
defer file.Close()
// Process file...
return nil
}
// Error unwrapping
func handleError(err error) {
var pathErr *os.PathError
if errors.As(err, &pathErr) {
fmt.Printf("Path error: %s\n", pathErr.Path)
}
if errors.Is(err, os.ErrNotExist) {
fmt.Println("File does not exist")
}
}
// Pattern pour resources cleanup
func processData() (err error) {
file, err := os.Open("data.txt")
if err != nil {
return err
}
defer func() {
if closeErr := file.Close(); closeErr != nil {
if err == nil {
err = closeErr
}
}
}()
// Process data...
return nil
}
// Panic et recover (usage limité)
func safeDivision(a, b int) (result int, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("panic occurred: %v", r)
}
}()
if b == 0 {
panic("division by zero")
}
return a / b, nil
}
🧠 Quiz - Gestion d'erreurs
- Pourquoi Go n'a-t-il pas d'exceptions ?
Réponse : Philosophie de Go : gestion explicite des erreurs pour plus de clarté et contrôle. - Quelle est la différence entre errors.Is() et errors.As() ?
Réponse : Is() compare les valeurs d'erreur, As() fait du type assertion sur les erreurs. - Quand utiliser panic() en Go ?
Réponse : Seulement pour les erreurs irrecupérables au démarrage ou les bugs de programmation. - Comment créer une erreur custom qui wrapp une autre erreur ?
Réponse : fmt.Errorf("message: %w", originalError) avec le verbe %w.
6. Tests et organisation du code
Les tests en Go sont intégrés au langage. Savoir écrire des tests est essentiel et souvent demandé en entretien pour évaluer vos pratiques de développement.
Testing patterns et organisation (temps d'apprentissage : 2-3h)
// Structure de package
package calculator
import (
"errors"
"testing"
)
// Code principal
func Add(a, b int) int {
return a + b
}
func Divide(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("division by zero")
}
return a / b, nil
}
// Tests (fichier calculator_test.go)
func TestAdd(t *testing.T) {
result := Add(2, 3)
expected := 5
if result != expected {
t.Errorf("Add(2, 3) = %d; want %d", result, expected)
}
}
// Table-driven tests (pattern recommandé)
func TestDivide(t *testing.T) {
tests := []struct {
name string
a, b float64
expected float64
hasError bool
}{
{"normal division", 10, 2, 5, false},
{"division by zero", 10, 0, 0, true},
{"negative numbers", -6, 2, -3, false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result, err := Divide(tt.a, tt.b)
if tt.hasError && err == nil {
t.Errorf("expected error but got none")
}
if !tt.hasError && err != nil {
t.Errorf("unexpected error: %v", err)
}
if !tt.hasError && result != tt.expected {
t.Errorf("Divide(%f, %f) = %f; want %f", tt.a, tt.b, result, tt.expected)
}
})
}
}
// Benchmark
func BenchmarkAdd(b *testing.B) {
for i := 0; i < b.N; i++ {
Add(1, 2)
}
}
🧠 Quiz - Tests
- Comment nommer un fichier de test en Go ?
Réponse : nomfichier_test.go dans le même package. - Quelle signature doit avoir une fonction de test ?
Réponse : func TestNom(t *testing.T) { ... } - Comment lancer uniquement les tests d'un package ?
Réponse : go test ./package-name ou go test . - Quelle est la différence entre t.Error() et t.Fatal() ?
Réponse : Error continue le test, Fatal arrête immédiatement le test.
7. 10 erreurs classiques à éviter en Go
Ces erreurs sont couramment commises par les développeurs venant d'autres langages et sont souvent utilisées comme pièges en entretien technique. Maîtriser ces points vous distinguera des autres candidats.
⚠️ Ces erreurs peuvent coûter cher en entretien :
- Modification de slice dans une boucle range
- Oubli de vérifier les erreurs
- Confusion pointeur vs valeur pour les receivers
- Fermeture de goroutine sur variable de boucle
1. Modification de slice pendant l'itération range
❌ Erreur commune : modification pendant range
// ❌ MAUVAIS : range copie les valeurs
func updateUsers(users []User) {
for _, user := range users {
user.Active = true // Ne modifie que la copie !
}
}
// ✅ CORRECT : utiliser l'index
func updateUsers(users []User) {
for i := range users {
users[i].Active = true // Modifie l'original
}
}
// ✅ CORRECT : utiliser des pointeurs
func updateUsersPtrs(users []*User) {
for _, user := range users {
user.Active = true // Modifie via le pointeur
}
}
2. Ignorer les erreurs
❌ Erreur fatale : ne pas gérer les erreurs
// ❌ MAUVAIS : ignore les erreurs
func badFileRead() {
data, _ := ioutil.ReadFile("config.json") // Erreur ignorée !
// Utilisation de data sans vérifier l'erreur
}
// ✅ CORRECT : toujours vérifier les erreurs
func goodFileRead() error {
data, err := ioutil.ReadFile("config.json")
if err != nil {
return fmt.Errorf("failed to read config: %w", err)
}
// Traiter data en sécurité
return nil
}
// ✅ Pattern pour erreurs multiples
func multipleOperations() error {
if err := operation1(); err != nil {
return fmt.Errorf("operation1 failed: %w", err)
}
if err := operation2(); err != nil {
return fmt.Errorf("operation2 failed: %w", err)
}
return nil
}
3. Confusion receivers : pointeur vs valeur
❌ Erreur de receiver : quand utiliser * ou pas ?
type Counter struct {
value int
}
// ❌ MAUVAIS : receiver par valeur pour modification
func (c Counter) Increment() {
c.value++ // Ne modifie que la copie !
}
// ✅ CORRECT : receiver par pointeur pour modification
func (c *Counter) Increment() {
c.value++ // Modifie l'original
}
// ✅ CORRECT : receiver par valeur pour lecture seule
func (c Counter) Value() int {
return c.value // Pas de modification, valeur OK
}
// Règle : Utiliser *T si :
// - La méthode modifie le receiver
// - Le receiver est une grande struct (performance)
// - Cohérence avec d'autres méthodes du type
4. Goroutine avec variable de boucle
❌ Piège classique : closure sur variable de boucle
// ❌ MAUVAIS : toutes les goroutines utilisent la même variable
func badGoroutines() {
for i := 0; i < 5; i++ {
go func() {
fmt.Println(i) // Imprime souvent 5, 5, 5, 5, 5
}()
}
time.Sleep(time.Second)
}
// ✅ CORRECT : passer la variable en paramètre
func goodGoroutines() {
for i := 0; i < 5; i++ {
go func(id int) {
fmt.Println(id) // Imprime 0, 1, 2, 3, 4
}(i)
}
time.Sleep(time.Second)
}
// ✅ CORRECT : créer une copie locale
func goodGoroutines2() {
for i := 0; i < 5; i++ {
i := i // Copie locale !
go func() {
fmt.Println(i) // Imprime 0, 1, 2, 3, 4
}()
}
time.Sleep(time.Second)
}
5. Interface{} mal utilisée
❌ Abus d'interface{} au lieu de types spécifiques
// ❌ MAUVAIS : interface{} partout
func badFunction(data interface{}) interface{} {
// Perte de type safety, difficile à maintenir
return data
}
// ✅ CORRECT : types spécifiques
func goodFunction(data string) (string, error) {
if data == "" {
return "", errors.New("empty string")
}
return strings.ToUpper(data), nil
}
// ✅ CORRECT : generics (Go 1.18+)
func genericFunction[T any](data T) T {
return data
}
// Utiliser interface{} seulement quand nécessaire :
// - JSON unmarshaling
// - Reflection
// - Containers génériques (avant Go 1.18)
8. Go vs autres langages - Tableau comparatif
Cette comparaison vous aide à expliquer les spécificités de Go par rapport aux langages que vous connaissez déjà, question fréquente en entretien.
| Concept | Go | JavaScript/TypeScript | Python | Java |
|---|---|---|---|---|
| Déclaration variable | var x int = 5 |
let x: number = 5 |
x = 5 |
int x = 5; |
| Arrays/Lists | []int{1,2,3} |
[1,2,3] |
[1,2,3] |
int[] arr = {1,2,3}; |
| Dictionnaires/Maps | map[string]int{ |
{a: 1} |
{"a": 1} |
HashMap<String,Integer> |
| Gestion d'erreurs | result, err := func() |
try { |
try: |
try { |
| Concurrence | go func() {} |
async/await |
asyncio |
Threads |
| Interfaces | Implicites (duck typing) |
Explicitesimplements |
Implicites (duck typing) |
Explicitesimplements |
🎯 Spécificités Go à retenir pour l'entretien
- Compilation native : Pas de VM, binaire autonome
- Garbage Collector : Gestion automatique mémoire mais contrôlable
- Goroutines : Concurrence légère (vs threads lourds)
- Interfaces implicites : Duck typing avec type safety
- Gestion d'erreurs explicite : Pas d'exceptions cachées
- Simplicité : 25 mots-clés seulement vs 50+ en Java
9. Questions typiques d'entretien Go
Voici les questions les plus fréquemment posées en entretien technique Go, organisées par thème. Préparez vos réponses à l'oral.
Questions générales sur Go
Questions ouvertes
- "Pourquoi avoir choisi Go pour ce projet ?"
Préparez : performance, simplicité, concurrence, écosystème, déploiement facile - "Quels sont les avantages et inconvénients de Go ?"
Avantages : compilation rapide, concurrence, simplicité. Inconvénients : verbosité, écosystème plus petit, pas de génériques (avant 1.18) - "Comment Go gère-t-il la mémoire ?"
Garbage collector, allocation stack vs heap, escape analysis - "Quelle est la philosophie 'Less is More' de Go ?"
Simplicité du langage, peu de mots-clés, une façon de faire les choses
Questions techniques spécifiques
Questions code/algorithmes
- "Implémentez une fonction qui inverse une string en Go"
- "Comment détecter une race condition ?"
go run -race, outils de détection, bonnes pratiques - "Expliquez la différence entre make() et new()"
make pour slices/maps/channels, new pour pointeurs vers zéro values - "Comment optimiser une goroutine qui fait beaucoup d'allocations ?"
Pools d'objets, réutilisation, profiling avec pprof - "Qu'est-ce que l'escape analysis ?"
Décision compilateur : stack vs heap allocation
Questions architecture et bonnes pratiques
Questions design
- "Comment structureriez-vous une API REST en Go ?"
Packages, handlers, middleware, validation, tests - "Comment géreriez-vous la configuration dans une app Go ?"
Environment variables, fichiers config, viper, 12-factor app - "Expliquez votre approche pour les tests en Go"
Table-driven tests, mocks, coverage, intégration - "Comment implémenteriez-vous un cache en Go ?"
Map + Mutex, TTL, LRU, considérations concurrence - "Décrivez un pattern pour gérer les timeouts dans une API"
Context, timeouts, circuit breakers
10. Mini-projet d'entretien : Worker Pool avec Rate Limiting
Exercice classique d'entretien technique Go : implémenter un pool de workers avec limitation de débit. Cet exercice teste la concurrence, les channels, et l'architecture Go.
📋 Énoncé du projet
Objectif : Créer un système de traitement de tâches concurrent avec les contraintes suivantes :
- Pool de N workers qui traitent des tâches en parallèle
- Rate limiting : maximum X tâches par seconde
- Timeout : une tâche ne doit pas durer plus de Y secondes
- Graceful shutdown : arrêt propre du système
- Métriques : nombre de tâches traitées, erreurs, temps moyen
Solution complète avec commentaires d'entretien
package main
import (
"context"
"fmt"
"log"
"strings"
"sync"
"time"
)
// Task représente une unité de travail
type Task struct {
ID int
Payload string
Result chan TaskResult
}
// TaskResult contient le résultat d'une tâche
type TaskResult struct {
TaskID int
Output string
Error error
Duration time.Duration
}
// WorkerPool gère un pool de workers avec rate limiting
type WorkerPool struct {
workerCount int
taskQueue chan Task
rateLimiter chan struct{} // Token bucket pour rate limiting
stats *Stats
ctx context.Context
cancel context.CancelFunc
wg sync.WaitGroup
}
// Stats collecte les métriques du pool
type Stats struct {
mu sync.RWMutex
tasksProcessed int64
tasksErrored int64
totalDuration time.Duration
}
func (s *Stats) AddTask(duration time.Duration, hasError bool) {
s.mu.Lock()
defer s.mu.Unlock()
s.tasksProcessed++
s.totalDuration += duration
if hasError {
s.tasksErrored++
}
}
func (s *Stats) GetStats() (processed, errored int64, avgDuration time.Duration) {
s.mu.RLock()
defer s.mu.RUnlock()
if s.tasksProcessed > 0 {
avgDuration = s.totalDuration / time.Duration(s.tasksProcessed)
}
return s.tasksProcessed, s.tasksErrored, avgDuration
}
// NewWorkerPool crée un nouveau pool de workers
// Paramètres souvent demandés en entretien
func NewWorkerPool(workerCount int, queueSize int, rateLimit int) *WorkerPool {
ctx, cancel := context.WithCancel(context.Background())
pool := &WorkerPool{
workerCount: workerCount,
taskQueue: make(chan Task, queueSize),
rateLimiter: make(chan struct{}, rateLimit), // Buffer = rate limit
stats: &Stats{},
ctx: ctx,
cancel: cancel,
}
// Initialiser le rate limiter
go pool.fillRateLimiter(rateLimit)
return pool
}
// fillRateLimiter remplit le token bucket pour le rate limiting
// Concept important : contrôler le débit d'exécution
func (wp *WorkerPool) fillRateLimiter(tokensPerSecond int) {
ticker := time.NewTicker(time.Second / time.Duration(tokensPerSecond))
defer ticker.Stop()
for {
select {
case <-wp.ctx.Done():
return
case <-ticker.C:
select {
case wp.rateLimiter <- struct{}{}:
// Token ajouté
default:
// Buffer plein, on drop le token
}
}
}
}
// Start démarre tous les workers
// Pattern classique : démarrage concurrent
func (wp *WorkerPool) Start() {
for i := 0; i < wp.workerCount; i++ {
wp.wg.Add(1)
go wp.worker(i)
}
log.Printf("Started %d workers", wp.workerCount)
}
// worker est la fonction principale de chaque worker
// Points d'évaluation : gestion contexte, timeout, rate limiting
func (wp *WorkerPool) worker(id int) {
defer wp.wg.Done()
for {
select {
case <-wp.ctx.Done():
log.Printf("Worker %d shutting down", id)
return
case task := <-wp.taskQueue:
// Attendre un token du rate limiter
select {
case <-wp.rateLimiter:
// Token obtenu, on peut traiter
case <-wp.ctx.Done():
// Arrêt demandé pendant l'attente
task.Result <- TaskResult{
TaskID: task.ID,
Error: fmt.Errorf("worker shutting down"),
}
return
}
// Traiter la tâche avec timeout
wp.processTask(task, id)
}
}
}
// processTask traite une tâche individuelle avec timeout
// Gestion du timeout : pattern très demandé en entretien
func (wp *WorkerPool) processTask(task Task, workerID int) {
start := time.Now()
// Context avec timeout pour cette tâche
taskCtx, cancel := context.WithTimeout(wp.ctx, 5*time.Second)
defer cancel()
// Channel pour le résultat
resultChan := make(chan TaskResult, 1)
// Goroutine pour le traitement effectif
go func() {
// Simulation du travail (remplacer par vraie logique)
output, err := wp.simulateWork(taskCtx, task.Payload)
resultChan <- TaskResult{
TaskID: task.ID,
Output: output,
Error: err,
Duration: time.Since(start),
}
}()
// Attendre le résultat ou timeout
select {
case result := <-resultChan:
wp.stats.AddTask(result.Duration, result.Error != nil)
task.Result <- result
log.Printf("Worker %d completed task %d in %v", workerID, task.ID, result.Duration)
case <-taskCtx.Done():
// Timeout atteint
result := TaskResult{
TaskID: task.ID,
Error: fmt.Errorf("task timeout after 5s"),
Duration: time.Since(start),
}
wp.stats.AddTask(result.Duration, true)
task.Result <- result
log.Printf("Worker %d: task %d timed out", workerID, task.ID)
}
}
// simulateWork simule le traitement d'une tâche
func (wp *WorkerPool) simulateWork(ctx context.Context, payload string) (string, error) {
// Simulation de travail variable
workTime := time.Duration(len(payload)*100) * time.Millisecond
select {
case <-time.After(workTime):
return fmt.Sprintf("Processed: %s", payload), nil
case <-ctx.Done():
return "", ctx.Err()
}
}
// Submit soumet une nouvelle tâche au pool
// Interface publique : gestion des erreurs et timeouts
func (wp *WorkerPool) Submit(taskID int, payload string) (*TaskResult, error) {
task := Task{
ID: taskID,
Payload: payload,
Result: make(chan TaskResult, 1),
}
// Timeout pour la soumission
select {
case wp.taskQueue <- task:
// Tâche soumise avec succès
case <-time.After(1 * time.Second):
return nil, fmt.Errorf("task queue full, timeout")
case <-wp.ctx.Done():
return nil, fmt.Errorf("worker pool shut down")
}
// Attendre le résultat
select {
case result := <-task.Result:
return &result, nil
case <-time.After(10 * time.Second):
return nil, fmt.Errorf("task result timeout")
}
}
// Shutdown arrête proprement le worker pool
// Graceful shutdown : concept important pour la production
func (wp *WorkerPool) Shutdown(timeout time.Duration) error {
log.Println("Initiating graceful shutdown...")
// Fermer la queue pour empêcher nouvelles tâches
close(wp.taskQueue)
// Channel pour signaler la fin
done := make(chan struct{})
go func() {
wp.wg.Wait() // Attendre que tous les workers finissent
close(done)
}()
// Attendre shutdown ou timeout
select {
case <-done:
wp.cancel() // Annuler le contexte
log.Println("Graceful shutdown completed")
return nil
case <-time.After(timeout):
wp.cancel() // Force shutdown
return fmt.Errorf("shutdown timeout, forced termination")
}
}
// GetStats retourne les statistiques actuelles
func (wp *WorkerPool) GetStats() (int64, int64, time.Duration) {
return wp.stats.GetStats()
}
// Exemple d'utilisation et tests
func main() {
// Configuration du pool
pool := NewWorkerPool(
3, // 3 workers
10, // Queue de 10 tâches
2, // 2 tâches par seconde max
)
// Démarrer le pool
pool.Start()
// Soumettre des tâches d'exemple
tasks := []string{
"task-alpha",
"task-beta",
"task-gamma",
"task-delta",
"task-epsilon",
}
// Goroutine pour soumettre les tâches
go func() {
for i, taskData := range tasks {
result, err := pool.Submit(i+1, taskData)
if err != nil {
log.Printf("Error submitting task %d: %v", i+1, err)
continue
}
if result.Error != nil {
log.Printf("Task %d failed: %v", result.TaskID, result.Error)
} else {
log.Printf("Task %d succeeded: %s (took %v)",
result.TaskID, result.Output, result.Duration)
}
}
}()
// Laisser tourner 30 secondes
time.Sleep(30 * time.Second)
// Afficher les stats
processed, errored, avgDuration := pool.GetStats()
fmt.Printf("\n=== STATISTICS ===\n")
fmt.Printf("Tasks processed: %d\n", processed)
fmt.Printf("Tasks errored: %d\n", errored)
fmt.Printf("Average duration: %v\n", avgDuration)
// Shutdown graceful
if err := pool.Shutdown(5 * time.Second); err != nil {
log.Printf("Shutdown error: %v", err)
}
}
// Tests unitaires pour démontrer la testabilité
func TestWorkerPool(t *testing.T) {
pool := NewWorkerPool(2, 5, 10) // Config pour tests
pool.Start()
defer pool.Shutdown(1 * time.Second)
// Test soumission normale
result, err := pool.Submit(1, "test-payload")
if err != nil {
t.Fatalf("Failed to submit task: %v", err)
}
if result.Error != nil {
t.Fatalf("Task failed: %v", result.Error)
}
if !strings.Contains(result.Output, "test-payload") {
t.Errorf("Expected output to contain 'test-payload', got: %s", result.Output)
}
// Vérifier les stats
processed, errored, _ := pool.GetStats()
if processed != 1 {
t.Errorf("Expected 1 processed task, got %d", processed)
}
if errored != 0 {
t.Errorf("Expected 0 errored tasks, got %d", errored)
}
}
🎯 Points d'évaluation de l'exercice
Ce que l'interviewer évalue :
- Concurrence : Goroutines, channels, WaitGroup, Context
- Rate limiting : Token bucket pattern, gestion du débit
- Timeout : Context avec deadline, select avec timeout
- Graceful shutdown : Arrêt propre, gestion des ressources
- Thread safety : Mutex pour les stats, channels pour communication
- Error handling : Gestion d'erreurs explicite, pas de panic
- Testability : Code modulaire, interfaces, tests unitaires
- Monitoring : Métriques, logs, observabilité
💡 Extensions possibles de l'exercice
Questions de follow-up courantes :
- "Comment ajouteriez-vous du retry automatique ?"
Exponential backoff, circuit breaker, dead letter queue - "Comment scaleriez-vous ce système ?"
Multiple instances, load balancing, persistence Redis/DB - "Comment monitoreriez-vous ce pool en production ?"
Prometheus metrics, health checks, alerting - "Comment gérer différents types de tâches ?"
Interfaces, factory pattern, priority queues - "Comment optimiser la performance ?"
Profiling, object pooling, batch processing
🎯 À Retenir pour l'entretien
- Maîtrisez les fondamentaux : Variables, types, fonctions, structures de contrôle
- Slices et maps : Différences avec arrays, manipulation, pièges courants
- Interfaces implicites : Duck typing, type assertions, interface{}
- Concurrence : Goroutines, channels, select, patterns worker pool
- Gestion d'erreurs : Pas d'exceptions, retours multiples, wrapping
- Tests : Table-driven tests, mocking, benchmarks
- Évitez les pièges : Range sur slices, goroutine leaks, race conditions
- Pratiquez le live coding : Worker pools, parsers JSON, algorithmes simples
- Connaissez l'écosystème : Modules, packages standards, outils (go fmt, go vet)
- Architectures : Clean architecture, microservices, APIs REST
🚀 Conseil final : L'entretien Go évalue autant votre compréhension de la concurrence que votre capacité à écrire du code simple et maintenable. Privilégiez la clarté à la complexité, et n'hésitez pas à expliquer vos choix techniques à voix haute.