1. 临界资源
package main
import (
"fmt"
"time"
)
func main() {
/*
临界资源：
*/
a := 1
go func() {
a = 2
fmt.Println("goroutine中。。",a)
}()
a = 3
time.Sleep(1)
fmt.Println("main goroutine...",a) //2
}
2. 同步等待组
package main
import (
"fmt"
"sync" //同步包
)
//同步等待组中有counter计数器，初始值为零
var wg sync.WaitGroup //创建同步等待组的对象
func main() {
/*
WaitGroup：同步等待组
Add()，设置等待组中要执行的子 goroutine的数量
Wait()，让主goroutine处于等待
Done()，让等待组中的counter计数器的值减1，同Add(-1)
*/
wg.Add(2)
//注意：如果counter为3，但是只有两个子goroutine被抓进来，
//counter的值只被减了两次1，最终值为1
//会报死锁的panic
go fun1() //子goroutine被加载到同步等待组中
go fun2() //子goroutine被加载到同步等待组中
fmt.Println("main 进入阻塞状态。。等待wg中的子goroutien结束。。")
wg.Wait() // 表示main goroutine进入等待，意味着阻塞
//计数器值为零是，解除阻塞
fmt.Println("main..解除阻塞。。")
}
func fun1() {
for i := 1; i < 10; i++ {
fmt.Println("fun1()函数中打印。。A ", i)
}
wg.Done() //给wg等待组中的counter数值减1。同 wg.Add(-1)
}
func fun2() {
defer wg.Done()
for j := 1; j < 10; j++ {
fmt.Println("\tfun2()函数打印。。", j)
}
}
3. 互斥锁
package main
import (
"fmt"
"time"
"math/rand"
"sync"
)
//全局变量，表示票
var ticket = 100 //100张票
var mutex sync.Mutex //创建锁头
var wg sync.WaitGroup //同步等待组对象
func main() {
/*
4个goroutine，模拟4个售票口
在使用互斥锁的时候，对资源操作完，一定要解锁。否则会出现程序异常，死锁等问题。
建议使用defer语句解锁
*/
wg.Add(4)
go saleTickets("售票口1")
go saleTickets("售票口2")
go saleTickets("售票口3")
go saleTickets("售票口4")
wg.Wait() //main要等待
fmt.Println("程序结束了。。。")
}
func saleTickets(name string) {
rand.Seed(time.Now().UnixNano())
defer wg.Done()
for {
//上锁
mutex.Lock()
if ticket > 0 {
//一个子goroutine开始卖票，睡觉，醒来，卖票（这张票已经被另一个g卖掉了，但是还会继续卖）
//time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond)
fmt.Println(name, "售出：", ticket)
ticket--
} else {
mutex.Unlock() //条件不满足，也要解锁，否则break后，就执行不到解锁
fmt.Println(name, "售罄，没有票了。。")
break
}
mutex.Unlock() //解锁
}
}
4. 读写锁
Go语言包中的 sync 包提供了两种锁类型：sync.Mutex 和 sync.RWMutex。其中RWMutex是基于Mutex实现的，只读锁的实现使用类似引用计数器的功能。
RWMutex是读/写互斥锁。锁可以由任意数量的读取器或单个编写器持有。RWMutex的零值是未锁定的mutex。
如果一个goroutine持有一个rRWMutex进行读取，而另一个goroutine可能调用lock，那么在释放初始读取锁之前，任何goroutine都不应该期望能够获取读取锁。特别是，这禁止递归读取锁定。这是为了确保锁最终可用；被阻止的锁调用会将新的读卡器排除在获取锁之外。
我们怎么理解读写锁呢？当有一个 goroutine 获得写锁定，其它无论是读锁定还是写锁定都将阻塞直到写解锁；当有一个 goroutine 获得读锁定，其它读锁定仍然可以继续；当有一个或任意多个读锁定，写锁定将等待所有读锁定解锁之后才能够进行写锁定。所以说这里的读锁定（RLock）目的其实是告诉写锁定：有很多人正在读取数据，你给我站一边去，等它们读（读解锁）完你再来写（写锁定）。我们可以将其总结为如下三条：
- 同时只能有一个 goroutine 能够获得写锁定。
- 同时可以有任意多个 gorouinte 获得读锁定。
- 同时只能存在写锁定或读锁定（读和写互斥）。
所以，RWMutex这个读写锁，该锁可以加多个读锁或者一个写锁，其经常用于读次数远远多于写次数的场景。
读写锁的写锁只能锁定一次，解锁前不能多次锁定，读锁可以多次，但读解锁次数最多只能比读锁次数多一次，一般情况下我们不建议读解锁次数多余读锁次数。
基本遵循两大原则：
1、可以随便读，多个goroutine同时读。 ? 2、写的时候，啥也不能干。不能读也不能写。
读写锁即是针对于读写操作的互斥锁。它与普通的互斥锁最大的不同就是，它可以分别针对读操作和写操作进行锁定和解锁操作。读写锁遵循的访问控制规则与互斥锁有所不同。在读写锁管辖的范围内，它允许任意个读操作的同时进行。但是在同一时刻，它只允许有一个写操作在进行。
并且在某一个写操作被进行的过程中，读操作的进行也是不被允许的。也就是说读写锁控制下的多个写操作之间都是互斥的，并且写操作与读操作之间也都是互斥的。但是，多个读操作之间却不存在互斥关系。
package main
import (
"fmt"
"sync"
"time"
)
var rwMutex *sync.RWMutex
//为了保证子的goroutine先执行，可以使用同步等待组
var wg *sync.WaitGroup
func main() {
rwMutex = new(sync.RWMutex)
wg = new(sync.WaitGroup)
//wg.Add(2)
//多个同时读取
//go readData(1)
//go readData(2)
wg.Add(3)
go writeData(1)
go readData(2)
go writeData(3)
wg.Wait()
fmt.Println("main..over...")
}
func writeData(i int) {
defer wg.Done()
fmt.Println(i, "开始写：write start。。")
rwMutex.Lock() //写操作上锁
fmt.Println(i, "正在写：writing。。。。")
time.Sleep(3 * time.Second)
rwMutex.Unlock()
fmt.Println(i, "写结束：write over。。")
}
func readData(i int) {
defer wg.Done()
fmt.Println(i, "开始读：read start。。")
rwMutex.RLock() //读操作上锁
fmt.Println(i, "正在读取数据：reading。。。")
time.Sleep(3 * time.Second) //写的操作是互斥的，能够感觉到这个睡眠时间
rwMutex.RUnlock() //读操作解锁
fmt.Println(i, "读结束：read over。。。")
}
原文地址：https://www.cnblogs.com/yzg-14/p/12254527.html