Golang语言中，进程间通信除了使用channel，还可以使用共享内存，即sync包。
Q-1
package main
import (
"fmt"
"time"
)
func main() {
for i := 1; i < 6; i++ {
go func(x int) {
time.Sleep(time.Second)
fmt.Println("第", x, "个子goroutine执行结束")
}(i)
}
fmt.Println("主goroutine执行结束")
}
上面的代码毫无疑问的只会输出：“主goroutine执行结束”，而不会输出子goroutine执行结束，这是因为，主协程一旦执行完毕，整个进程就会结束。
sync组等待
sync包中常用的有三个方法：Add(num int) 、 Done()、 Wait()
sync中会在内部维持一个类似于计数器的东西，通过Add方法来增加计数器的值，增加参数num；通过Done来减少计数器的值，一次只能减少1；Wait方法会使主协程阻塞，只有到内部计数器的值为0时，阻塞才会解开。
用法如下：
package main
import (
"fmt"
"sync"
"time"
)
func main() {
var wg sync.WaitGroup
for i := 1; i < 6; i++ {
wg.Add(1) //计数器加1
go func(x int) {
time.Sleep(time.Second)
fmt.Println("第", x, "个子goroutine执行结束")
wg.Done() //goroutine执行完毕，计数器减1
}(i)
}
wg.Wait() // 计数器不为0的时候，一直阻塞；计数器变为0的时候，阻塞解开
fmt.Println("主goroutine执行结束")
}
注意：添加的计时器数量必须比减少计时器的数量要少，否则会引发死锁。
比如，将计数器值增加了10，但是只执行了9次计数器减少，剩余一个计数器，计数器的值始终不为0，则主协程一直等待，形成死锁。但是较少计数器的次数可以比计数器的值要大，可以提前结束主协程的阻塞。
Q-2
请看下面一段代码，尝试在两个循环中，各自使sum加1，执行1000次，乍一看，觉得结果是sum的最终结果是2000，但是真正执行之后，结果不是2000。
package main
import (
"fmt"
"sync"
)
func main() {
var wg sync.WaitGroup
wg.Add(2)
var sum int = 0
go func() {
for i := 0; i < 1000; i++ {
sum++
}
wg.Done()
}()
go func() {
for i := 0; i < 1000; i++ {
sum++
}
wg.Done()
}()
wg.Wait()
fmt.Println(sum)
}
sync互斥锁
sync互斥锁有两个常用的方法，Lock()加锁，Unlock()解锁。使用Lock加锁后，不能再进行加锁，只有当对其进行Unlock解锁之后，才能对其加锁。这个很好理解。
如果对一个未加锁的资源进行解锁，会引发panic异常。
可以在一个goroutine中对一个资源加锁，而在另外一个goroutine中对该资源进行解锁。
使用示例如下：
package main
import (
"fmt"
"sync"
)
func main() {
var wg sync.WaitGroup
var mutex sync.Mutex
wg.Add(2)
var sum int = 0
go func() {
for i := 0; i < 1000; i++ {
mutex.Lock() //上锁
sum++
mutex.Unlock()//解锁
}
wg.Done()
}()
go func() {
for i := 0; i < 1000; i++ {
mutex.Lock() //加锁
sum++
mutex.Unlock() //解锁
}
wg.Done()
}()
wg.Wait()
fmt.Println(sum)
}
sync读写互斥锁（多读单写锁）
允许对同一资源进行同时读，但是不能进行同时写，也不能进行一边读，一边写。
如果一个资源被加了写锁，那么就不能再给他加其他锁，包括写锁，只能等写锁解开后，才能继续加其他锁。如果一个资源被加了读锁，那么，仍然可以给该资源加读锁，但是不能加写锁，必须等读锁释放后，才能加写锁。
sync.RWMutex有四个常用的方法：
Lock()加写锁 、 Unlock()取消写锁 、 RLock()加读锁 、 RUnlock()释放读锁
使用示例：
package main
import (
"fmt"
"sync"
"time"
)
var rwMutex sync.RWMutex //定义一个读写互斥锁
//注意传递的组等待是指针形式
func WriteData(wg *sync.WaitGroup, id int) {
rwMutex.Lock() //加 写锁
fmt.Println("增加第", id, "个写锁")
for i := 0; i < 5; i++ {
fmt.Println("进行写操作")
time.Sleep(time.Second)
}
fmt.Println("释放第", id, "个写锁")
rwMutex.Unlock() //释放 写锁
wg.Done()
}
func ReadData(wg *sync.WaitGroup, id int) {
rwMutex.RLock() //加 读锁
fmt.Println("增加第", id, "个读锁")
for i := 0; i < 5; i++ {
fmt.Println("进行读操作")
time.Sleep(time.Second)
}
fmt.Println("释放第", id, "个读锁")
rwMutex.RUnlock() //释放 读锁
wg.Done()
}
func main() {
var wg sync.WaitGroup
for i := 1; i < 3; i++ {
wg.Add(1)
go WriteData(&wg, i)
}
for i := 1; i < 4; i++ {
wg.Add(1)
go ReadData(&wg, i)
}
wg.Wait()
fmt.Println("主程序执行完毕")
}
运行之后，就会发现，只有一个写加锁，只有写解锁之后，才允许加其他锁；如果是加读锁之后，可以再加读锁。
Q-3
package main
import (
"fmt"
"sync"
)
func demo() {
fmt.Println("运行demo函数")
}
func main() {
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
go func() {
demo()
wg.Done()
}()
}
wg.Wait()
fmt.Println("主程序结束")
}
这个示例代码运行之后，会输出10次“运行demo函数”，因为有10个goroutine，每个goroutine都运行了1次。
现在的需求是：虽然有10个goroutine，但是希望只有一个goroutine中执行demo函数，如果一个goroutine执行过了demo函数，其他的goroutine就会忽略demo函数，不去执行demo，保证demo函数只被执行一次。
sync.once初始化
sync.Once就是用来解决上面这个问题的：Once的作用就是多次调用，但只执行一次，Once只有一个方法->Once.Do(func)，向Do中传入一个函数，在第一次执行Once.Do()的时候，才执行传入的func，以后在执行Once.Do()，就不会再执行传入的func。
示例如下：
package main
import (
"fmt"
"sync"
)
func demo() {
fmt.Println("运行demo函数")
}
func main() {
var wg sync.WaitGroup
var once sync.Once
for i := 0; i < 10; i++ {
wg.Add(1)
go func() {
once.Do(demo)
//注意不要写成once.Do(demo()),这样写是把demo()的运行结果传入Do
wg.Done()
}()
}
wg.Wait()
fmt.Println("主程序结束")
}
这样就不会执行多次demo()，而只输出一次“运行demo函数”
