# Go互斥體實例

10goroutine在狀態和互斥體上工作一秒鐘。採集和報告最終操作計數。

mutexes.go的完整代碼如下所示 -

package main

import (
"fmt"
"math/rand"
"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{}

// We'll keep track of how many read and write
// operations we do.
var writeOps uint64 = 0

// Here we start 100 goroutines to execute repeated
// reads against the state, once per millisecond in
// each goroutine.
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 readOps count.
key := rand.Intn(5)
mutex.Lock()
total += state[key]
mutex.Unlock()

// Wait a bit between reads.
time.Sleep(time.Millisecond)
}
}()
}

// 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()
time.Sleep(time.Millisecond)
}
}()
}

// Let the 10 goroutines work on the state and
// mutex for a second.
time.Sleep(time.Second)

// Take and report final operation counts.
fmt.Println("writeOps:", writeOpsFinal)

// With a final lock of state, show how it ended up.
mutex.Lock()
fmt.Println("state:", state)
mutex.Unlock()
}

F:\worksp\golang>go run mutexes.go
state: map[0:99 3:3 4:62 1:18 2:89]