Go con Ejemplos: Mutexes

In the previous example we saw how to manage simple counter state using atomic operations. For more complex state we can use a mutex to safely access data across multiple goroutines.

package main
import (
    "fmt"
    "math/rand"
    "runtime"
    "sync"
    "sync/atomic"
    "time"
)
func main() {

For our example the state will be a map.

    var state = make(map[int]int)

This mutex will synchronize access to state.

    var mutex = &sync.Mutex{}

To compare the mutex-based approach with another we’ll see later, ops will count how many operations we perform against the state.

    var ops int64 = 0

Here we start 100 goroutines to execute repeated reads against the state.

    for r := 0; r < 100; r++ {
        go func() {
            total := 0
            for {

For each read we pick a key to access, Lock() the mutex to ensure exclusive access to the state, read the value at the chosen key, Unlock() the mutex, and increment the ops count.

                key := rand.Intn(5)
                mutex.Lock()
                total += state[key]
                mutex.Unlock()
                atomic.AddInt64(&ops, 1)

In order to ensure that this goroutine doesn’t starve the scheduler, we explicitly yield after each operation with runtime.Gosched(). This yielding is handled automatically with e.g. every channel operation and for blocking calls like time.Sleep, but in this case we need to do it manually.

                runtime.Gosched()
            }
        }()
    }

We’ll also start 10 goroutines to simulate writes, using the same pattern we did for reads.

    for w := 0; w < 10; w++ {
        go func() {
            for {
                key := rand.Intn(5)
                val := rand.Intn(100)
                mutex.Lock()
                state[key] = val
                mutex.Unlock()
                atomic.AddInt64(&ops, 1)
                runtime.Gosched()
            }
        }()
    }

Let the 10 goroutines work on the state and mutex for a second.

    time.Sleep(time.Second)

Take and report a final operations count.

    opsFinal := atomic.LoadInt64(&ops)
    fmt.Println("ops:", opsFinal)

With a final lock of state, show how it ended up.

    mutex.Lock()
    fmt.Println("state:", state)
    mutex.Unlock()
}

Running the program shows that we executed about 3,500,000 operations against our mutex-synchronized state.

$ go run mutexes.go
ops: 3598302
state: map[1:38 4:98 2:23 3:85 0:44]

Next we’ll look at implementing this same state management task using only goroutines and channels.

Siguiente ejemplo: Stateful Goroutines.