使用go来访问共享变量避免冲突的时候可以用 sync.Mutex这个类型，其中的Lock和Unlok方法可以保证在使用该变量的时候只能有一个进程可以访问该变量，从而避免冲突。 （其实就是实现互斥

    1. package main
    3. import (
    4.     "fmt"
    5.     "sync"
    6.     "time"
    7. )
    9. type SafeCounter struct {
    10.     v map[string]int
    11.     // 互斥锁类型，拥有两个方法
    12.     mux sync.Mutex
    13. }
    15. // Inc增加给定key的计数器的值
    16. func (c *SafeCounter) Inc(key string) {
    17.     c.mux.Lock()
    18.     //Lock之后同一时刻只能有一个goroutine能访问c.v
    19.     c.v[key]++
    20.     c.mux.Unlock()
    21. }
    23. // Value返回给定key的计数器的当前值
    24. func (c *SafeCounter) Value(key string) int {
    25.     c.mux.Lock()
    26.     // 用defer来保证互斥锁一定会被解锁
    27.     defer c.mux.Unlock()
    28.     return c.v[key]
    29. }
    31. func main() {
    32.     c := SafeCounter{v: make(map[string]int)}
    33.     for i := 0; i < 10000000; i++ {
    34.         go c.Inc("somekey")
    35.     }
    36.     //感觉这一句没啥用啊，为啥要写在这，让go程睡一会儿吗
    37.     // 但是上面的go程已经执行完了啊
    38.     // time.Sleep(5 * time.Millisecond)
    39.     //注释掉以后发现这句时必须的，不然的话没法每次输出的值都不一样
    40.     // 据说time.Tick可代替time.Sleep
    41.     time.Tick(50 * time.Millisecond)
    42.     // 输出有多少个"somekey"
    43.     fmt.Println(c.Value("somekey"))
    44.     fmt.Println(c.v) //ouput: map[somekey:10000000]
    46. }