Go并发编程指南第一篇
竞争条件和数据竞争
当两个或多个操作必须以正确的顺序执行时，就会出现竞争条件，但程序尚未编写为保证维护此顺序。
数据竞争是指一个并发操作试图读取一个变量，而在某个不确定的时间另一个并发操作试图写入同一个变量。main func 是主 goroutine。 func main() { var data int go func() { data++ }() if data == 0 { fmt.Printf(＂the value is %d＂, data) } }sync内存访问同步
sync 包包含对低级内存访问同步最有用的并发原语。临界区是代码中可以访问共享内存的地方mutex互斥体
Mutex 代表＂互斥＂，是一种保护程序关键部分的方法。 type Counter struct { mu sync.Mutex value int } func (c *Counter) Increment() { c.mu.Lock() defer c.mu.Unlock() c.value++ }waitgroup等待组
调用添加一组goroutines var wg sync.WaitGroup for _, salutation := range []string{＂hello＂, ＂greetings＂, ＂good day＂} { wg.Add(1) go func(salutation string) { defer wg.Done() fmt.Println(salutation) }(salutation) } wg.Wait()读写互斥锁
更细粒度的内存控制，可以请求只读锁 producer := func(wg *sync.WaitGroup, l sync.Locker) { defer wg.Done() for i := 5; i > 0; i-- { l.Lock() l.Unlock() time.Sleep(1) } } observer := func(wg *sync.WaitGroup, l sync.Locker) { defer wg.Done() l.Lock() defer l.Unlock() } test := func(count int, mutex, rwMutex sync.Locker) time.Duration { var wg sync.WaitGroup wg.Add(count+1) beginTestTime := time.Now() go producer(&wg, mutex) for i := count; i > 0; i-- { go observer(&wg, rwMutex) } wg.Wait() return time.Since(beginTestTime) } tw := tabwriter.NewWriter(os.Stdout, 0, 1, 2, ＂ ＂, 0) defer tw.Flush() var m sync.RWMutex fmt.Fprintf(tw, ＂Readers RWMutex Mutex ＂) for i := 0; i < 20; i++ { count := int(math.Pow(2, float64(i))) fmt.Fprintf( tw, ＂%d %v %v ＂, count, test(count, &m, m.RLocker()), test(count, &m, &m), ) }cond条件
如果有某种方法可以让 goroutine 有效地休眠，直到收到唤醒并检查其状态的信号，那就更好了。这正是 Cond 类型为我们所做的。
Cond 和 Broadcast 是用于通知在 Wait 调用中阻塞的 goroutines 条件已被触发的方法。 type Button struct { Clicked *sync.Cond } func main() { button := Button{ Clicked: sync.NewCond(&sync.Mutex{}), } // running on goroutine every function that passed/registered // and wait, not exit until that goroutine is confirmed to be running subscribe := func(c *sync.Cond, param string, fn func(s string)) { var goroutineRunning sync.WaitGroup goroutineRunning.Add(1) go func(p string) { goroutineRunning.Done() c.L.Lock() // critical section defer c.L.Unlock() fmt.Println(＂Registered and wait ... ＂) c.Wait() fn(p) }(param) goroutineRunning.Wait() } var clickRegistered sync.WaitGroup for _, v := range []string{ ＂Maximizing window.＂, ＂Displaying annoying dialog box!＂, ＂Mouse clicked.＂} { clickRegistered.Add(1) subscribe(button.Clicked, v, func(s string) { fmt.Println(s) clickRegistered.Done() }) } button.Clicked.Broadcast() clickRegistered.Wait() }Once
确保即使在多个 goroutine 之间也只执行一次 var count int increment := func() { count++ } var once sync.Once var increments sync.WaitGroup increments.Add(100) for i := 0; i < 100; i++ { go func() { defer increments.Done() once.Do(increment) }() } increments.Wait() fmt.Printf(＂Count is %d ＂, count)Pool
管理连接池，数量 package main import ( ＂fmt＂ ＂sync＂ ) func main() { myPool := &sync.Pool{ New: func() interface{} { fmt.Println(＂Creating new instance.＂) return struct{}{} }, } // Get call New function defined in pool if there is no instance started myPool.Get() instance := myPool.Get() fmt.Println(＂instance＂, instance) // here we put a previously retrieved instance back into the pool, // this increases the number of instances available to one myPool.Put(instance) // when this call is executed, we will reuse the // previously allocated instance and put it back in the pool myPool.Get() var numCalcsCreated int calcPool := &sync.Pool{ New: func() interface{} { fmt.Println(＂new calc pool＂) numCalcsCreated += 1 mem := make([]byte, 1024) return &mem }, } fmt.Println(＂calcPool.New＂, calcPool.New()) calcPool.Put(calcPool.New()) calcPool.Put(calcPool.New()) calcPool.Put(calcPool.New()) calcPool.Put(calcPool.New()) calcPool.Get() const numWorkers = 1024 * 1024 var wg sync.WaitGroup wg.Add(numWorkers) for i := numWorkers; i > 0; i-- { go func() { defer wg.Done() mem := calcPool.Get().(*[]byte) defer calcPool.Put(mem) // Assume something interesting, but quick is being done with // this memory. }() } wg.Wait() fmt.Printf(＂%d calculators were created.＂, numCalcsCreated) }死锁
死锁是其中所有并发进程都在等待彼此。 package main import ( ＂fmt＂ ＂sync＂ ＂time＂ ) type value struct { mu sync.Mutex value int } func main() { var wg sync.WaitGroup printSum := func(v1, v2 *value) { defer wg.Done() v1.mu.Lock() defer v1.mu.Unlock() // deadlock time.Sleep(2 * time.Second) v2.mu.Lock() defer v2.mu.Unlock() fmt.Printf(＂sum=%v ＂, v1.value+v2.value) } var a, b value wg.Add(2) go printSum(&a, &b) go printSum(&b, &a) wg.Wait() }
总结
本文是go语言并发编程指南最佳实践第一篇，后续第二篇还会整理各种channel的特性，锁的使用在并发编程中的特点与各种用途举例，全部都是最接地气的代码示例。关注我，敬请期待下一篇。