Go 并发常用知识点实例

Go中天然的支持并发，Go允许使用go语句开启一个新的运行期线程，即 goroutine，以一个不同的、新创建的goroutine来执行一个函数。同一个程序中的所有goroutine共享同一个地址空间。

Goroutine非常轻量，除了为之分配的栈空间，其所占用的内存空间微乎其微。并且其栈空间在开始时非常小，之后随着堆存储空间的按需分配或释放而变化。内部实现上，goroutine会在多个操作系统线程上多路复用。如果一个goroutine阻塞了一个操作系统线程，例如：等待输入，这个线程上的其他goroutine就会迁移到其他线程，这样能继续运行。开发者并不需要关心/担心这些细节。

下面整理了并发编程中可能会经常用到的基本知识点，主要是channel的使用以及sync包的使用。

1、channel使用

channel通常用来在多个线程之间传递消息或者进行同步，channel的基本语法这里不再赘述，直接上一个实例代码：

package main

import (
	"fmt"
	"time"
)

func worker(dead <-chan bool, index int) {
	fmt.Println("Worker ", index, " Start!")
	for {
		select {
			case <-dead:
				fmt.Println("Worker ", index, " Done!")
				break
			default :
				//fmt.Println("Worker ", index, "Doing...") 
		}
	}
}

func worker2(done chan<- int, index int) {
	fmt.Println("Worker ", index, " Start!")
	time.Sleep(time.Second * 5)
	done <- index
}

func main() {
    
    /*
	//单个channel，unbuffered channel 同步用法
	c := make(chan bool)
	go func(){
			fmt.Println("goruntine child Test!")
			c <- true
		}()
	<- c
	fmt.Println("goruntine main Test!")	
    */

    
    /*
    //单个channel，buffered channel 异步用法
    c := make(chan int, 3)
    go func(){
    		for i := 0; i < 4; i++ {
    			c <- i
    			fmt.Println("write to c: ", i)
    		}
    	}()
	for j := 0; j < 4; j++ {
		fmt.Println("read from c: ", <-c)
	}
	*/

	
	/*
	//协同多个goruntine，unbuffeered channel 同步用法
	c := make(chan bool)
	fmt.Println("Start Master process!")
	for i := 1; i < 5; i++ {
		go func(index int){
			fmt.Println("Worker ", index, " Start!")
			<- c
			fmt.Println("Worker ", index, " Done!")
		}(i)
	}
	for j := 1; j < 5; j++ {
		c <- true
	}
	fmt.Println("Master Done!")
	*/
	
	
	/*
	//select 用法
	die := make(chan bool)
	for i := 0; i < 5; i++ {
		go worker(die, i)
	}

	time.Sleep(time.Second)
	for i := 0; i < 5; i++ {
		die <- true
	}
	*/
	
	
	fmt.Println("Master Start!")
	c1 := make(chan int)
	c2 := make(chan int)
	c3 := make(chan int)
	c4 := make(chan int)
	go worker2(c1, 1)
	go worker2(c2, 2)
	go worker2(c3, 3)
	go worker2(c4, 4)
	num := 0
Done:
	for {
		select {
		case <- c1 :
			fmt.Println("Worker 1 Done!")
			num += 1
		case <- c2 :
			fmt.Println("Worker 2 Done!")
			num += 1
		case <- c3 :
			fmt.Println("Worker 3 Done!")
			num += 1
		case <- c4 :
			fmt.Println("Worker 4 Done!")
			num += 1
		default :
			if num >= 4 {
				break Done
			}
		}
	}
	fmt.Println("Master Done!")
}

2、sync.Cond 使用

Cond是条件等待，条件等待通过 Wait 让例程等待，通过 Signal 让一个等待的例程继续，通过 Broadcast 让所有等待的例程继续。

在 Wait 之前应当手动为 c.L 上锁，Wait 结束后手动解锁。为避免虚假唤醒，需要将 Wait 放到一个条件判断循环中。官方要求的写法如下：

c.L.Lock()
for !condition() {
    c.Wait()
}
// 执行条件满足之后的动作...
c.L.Unlock()

Cond 在开始使用之后，不能再被复制。

示例代码如下：

package main

import (
	"fmt"
	"time"
	"sync"
)

func waiter(cond *sync.Cond, id int){
	cond.L.Lock()
	cond.Wait()
	cond.L.Unlock()

	fmt.Println("Waiter ", id, "wake up!")
}

func main() {
	locker := new(sync.Mutex)
	cond := sync.NewCond(locker)

	for i := 0; i < 3; i++ {
		go waiter(cond, i)
	}
	time.Sleep(time.Second * 3)

	cond.L.Lock()
	cond.Signal()
	cond.L.Unlock()

	for i := 3; i < 5; i++ {
		go waiter(cond, i)
	}
	time.Sleep(time.Second * 3)

	cond.L.Lock()
	cond.Signal()
	cond.L.Unlock()

	cond.L.Lock()
	cond.Broadcast()
	cond.L.Unlock()

	time.Sleep(time.Second * 5)
}

3、sync.Mutex使用

Mutex是互斥锁，用来保证在任一时刻，只能有一个例程访问某对象。Mutex 的初始值为解锁状态。Mutex 通常作为其它结构体的匿名字段使用，使该结构体具有 Lock 和 Unlock 方法。

Mutex 可以安全的在多个例程中并行使用。

示例代码如下：

package main

import (
	"fmt"
	"sync"
)

func click(c chan bool, count *int) {
	for i := 0; i < 1000; i++ {
		*count += 1
	}
	c <- true
}

func clickWithMutex(c chan bool, count *int, m *sync.Mutex) {
	for i := 0; i < 1000; i++ {
		m.Lock()
		*count += 1
		m.Unlock()
	}
	c <- true
}

func main() {
	m := new(sync.Mutex)
	count1, count2 := 0, 0
	c := make(chan bool, 10)

	for i := 0; i < 5; i++ {
		go click(c, &count1)
	}

	for i := 0; i < 5; i++ {
		go clickWithMutex(c, &count2, m)
	}

	for i := 0; i < 10; i++ {
		<- c
	}

	fmt.Println("count1: ", count1)
	fmt.Println("count2: ", count2)
}

4、sync.Once使用

Once是单次执行。

Once 的作用是多次调用但只执行一次，Once 只有一个方法，Once.Do()，向 Do 传入一个函数，这个函数在第一次执行 Once.Do() 的时候会被调用，以后再执行 Once.Do() 将没有任何动作，即使传入了其它的函数，也不会被执行，如果要执行其它函数，需要重新创建一个 Once 对象。

Once 可以安全的在多个例程中并行使用。

示例代码：

package main

import (
	"fmt"
	"sync"
)

func main() {
	once := new(sync.Once)
	ch := make(chan bool, 5)

	for i := 0; i < 5; i++ {
		go func(x int){
			once.Do(func(){
				fmt.Println("Worker Do: ", x)
			})
			fmt.Println("Master Do: ", i)
			ch <- true
		}(i)
	}

	for j := 0; j < 5; j++ {
		<- ch
	}

}

5、sync.RWMutex使用

RWMutex是读写互斥锁。

RWMutex 比 Mutex 多了一个“读锁定”和“读解锁”，可以让多个例程同时读取某对象。RWMutex 的初始值为解锁状态。RWMutex 通常作为其它结构体的匿名字段使用。

Mutex 可以安全的在多个例程中并行使用。

示例代码：

package main

import (
	"fmt"
	"sync"
)

func clickWithRWMutex(m *sync.RWMutex, total *int, ch chan int) {
	for i := 0; i < 1000; i++ {
		m.Lock()
		*total += 1
		m.Unlock()

		if i == 500 {
			m.RLock()
			fmt.Println("Middle Num: ", *total)
			m.RUnlock()
		}
	}
	ch <- 1
}

func main() {
	m := new(sync.RWMutex)
	ch := make(chan int, 10)
	count := 0

	for i := 0; i < 10; i++ {
		go clickWithRWMutex(m, &count, ch)
	}

	for i := 0; i < 10; i++ {
		<- ch
	}

	fmt.Println("Count: ", count)
}

6、sync.WaitGroup使用

WaitGroup是组等待。

WaitGroup 用于等待一组例程的结束。主例程在创建每个子例程的时候先调用 Add 增加等待计数，每个子例程在结束时调用 Done 减少例程计数。之后，主例程通过 Wait 方法开始等待，直到计数器归零才继续执行。

示例代码：

package main

import (
	"sync"
	"fmt"
)

func wgProcess(wg *sync.WaitGroup, index int) {
	fmt.Println("WgProcess ", index, "is going!")
	wg.Done()
}

func main() {
	wg := new(sync.WaitGroup)

	for i := 0; i < 20; i++ {
		wg.Add(1)
		go wgProcess(wg, i)
	}

	wg.Wait()
	fmt.Println("All is Done!")
}

7、sync/atomic 使用

sync/atomic是原子操作，具体未完待续。。。。。。

参考资料：

http://blog.xiayf.cn/2015/05/20/fundamentals-of-concurrent-programming/

https://github.com/astaxie/gopkg/tree/master/sync

https://www.cnblogs.com/golove/p/5918082.html