CodeUtility
Facilitiamo la vita agli sviluppatori!
Concorrenza in Go

Go sync.Mutex

Stop goroutines from losing updates when they change the same value.

  • Avanzato
  • 4 min di lettura
  • 1 esempio eseguibile
Cosa imparerai
  • Lock and Unlock
  • defer Unlock
  • Why the count is always right
Esegui il codice →
4 goroutines x 1000 increments
  1. 1mu.Lock()one at a time
  2. 2count++safe update
  3. 3mu.Unlock()next goroutine
  4. 44000always

One goroutine at a time

When goroutines change the same variable at the same time, updates can be lost. A Mutex is a lock: only the goroutine that holds it may touch the data.

Lock waits until no other goroutine holds the lock, and defer Unlock releases it when the method returns. Without the mutex, count++ from four goroutines would lose updates. Four goroutines each add 1000, so the result is always 4000.

Punti chiave

  1. Lock waits until the mutex is free.
  2. defer Unlock releases it on return.
  3. Without a lock, count++ can lose updates.

Esempio Go eseguibile

Go
Esegui il codice →
main.go
package main

import (
	"fmt"
	"sync"
)

type Counter struct {
	mu    sync.Mutex
	count int
}

func (c *Counter) Increment() {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.count++
}

func (c *Counter) Value() int {
	c.mu.Lock()
	defer c.mu.Unlock()
	return c.count
}

func main() {
	counter := &Counter{}
	var wg sync.WaitGroup

	for i := 0; i < 4; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			for j := 0; j < 1000; j++ {
				counter.Increment()
			}
		}()
	}

	wg.Wait()
	fmt.Println("final count:", counter.Value())
}
Crea un pulsante Run per questo esempio Risultato dell'esecuzione
final count: 4000

Esercitati

Apri l'esempio nel compilatore online, cambia un valore o aggiungi una riga e prova a prevedere l'output prima di eseguirlo. Poi rompi il codice di proposito e leggi il messaggio del compilatore.

Hai finito questa lezione?

Segnala come imparata per tenere traccia dei tuoi progressi.

Prossima: Worker Pool →

Esercitati con una sfida

Usa ciò che questa lezione spiega per risolvere un problema reale. Ogni sfida gira nel browser, con test immediati e una revisione dell'IA.

Tutte le sfide