什么是死锁、活锁
什么是死锁：就是在并发程序中，两个或多个线程彼此等待对方完成操作，从而导致它们都被阻塞，并无限期地等待对方完成。这种情况下，程序会卡死，无法继续执行。
什么是活锁：就是程序一直在运行，但是无法取得进展。例如，在某些情况下，多个线程会争夺同一个资源，然后每个线程都会释放资源，以便其他线程可以使用它。但是，如果没有正确的同步，这些线程可能会同时尝试获取该资源，然后再次释放它。这可能导致线程在无限循环中运行，却无法取得进展。
发生死锁的案例分析
- 编写会发生死锁的代码：
package main import ( "fmt" "sync" ) func main() { var mu sync.Mutex mu.Lock() defer mu.Unlock() wg := sync.WaitGroup{} wg.Add(1) go func() { fmt.Println("goroutine started") mu.Lock() // 在这里获取了锁 fmt.Println("goroutine finished") mu.Unlock() wg.Done() }() wg.Wait() }
运行和输出：
[root@workhost temp02]# go run main.go goroutine started fatal error: all goroutines are asleep - deadlock! # 错误很明显了，告诉你死锁啦！ goroutine 1 [semacquire]: sync.runtime_Semacquire(0xc000010030?) /usr/local/go/src/runtime/sema.go:62 +0x27 ... ...
上面的代码，使用 sync.Mutex 实现了一个互斥锁。主 goroutine 获取了锁，并启动了一个新的 goroutine。新 goroutine 也尝试获取锁来执行其任务。但是，由于主 goroutine 没有释放锁，新 goroutine 将一直等待锁，导致死锁。
- 代码改造
在上面的代码中，可以通过将主 goroutine 中的 defer mu.Unlock() 移到 goroutine 函数中的 mu.Unlock() 后面来解决问题。这样，当 goroutine 获取到锁后，它可以在完成任务后释放锁，以便主 goroutine 可以继续执行。
改造后的代码：
package main import ( "fmt" "sync" ) func main() { var mu sync.Mutex mu.Lock() wg := sync.WaitGroup{} wg.Add(1) go func() { fmt.Println("goroutine started") mu.Lock() // 在这里获取了锁 fmt.Println("goroutine finished") mu.Unlock() wg.Done() }() mu.Unlock() // 释放锁 wg.Wait() }
运行和输出：
[root@workhost temp02]# go run main.go goroutine started goroutine finished
- 如何避免死锁
在 Go 语言中，要避免死锁，一定要清楚以下几个规则：
- 避免嵌套锁：在使用多个锁时，确保它们的嵌套顺序相同。否则，可能会出现循环等待的情况，导致死锁。
- 避免无限等待：如果在获取锁时指定了超时时间，确保在超时后能够处理错误或执行其他操作。
- 避免过度竞争：如果多个协程需要访问相同的资源，请确保它们不会互相干扰。可以使用互斥锁或读写锁等机制来解决竞争问题。
- 使用通道：Go 语言中的通道可以用于协调并发操作。使用通道来传递消息和同步操作，可以避免死锁和竞争问题。
- 确保资源释放：在使用锁或其他资源时，一定要确保它们在使用后得到释放，否则可能会导致死锁。
- 使用 select 语句：在使用通道进行并发操作时，可以使用 select 语句来避免死锁。通过 select 语句选择多个通道中的一个进行操作，可以避免在某个通道被阻塞时出现死锁。
发生活锁的案例分析
- 编写会发生活锁的代码：
package main import ( "fmt" "sync" ) func main() { var wg sync.WaitGroup var mu sync.Mutex var flag bool wg.Add(2) // goroutine 1 go func() { // 先获取锁资源 fmt.Println("goroutine 1 获取 mu") mu.Lock() defer mu.Unlock() // 然后等待 flag 变量的值变为 true fmt.Println("goroutine 1 等待标志") for !flag { // 不断循环等待 } // 最终输出并释放锁资源 fmt.Println("goroutine 1 从等待中释放") wg.Done() }() // goroutine 2 go func() { // 先获取锁资源 fmt.Println("goroutine 2 获取 mu") mu.Lock() defer mu.Unlock() // 然后等待 flag 变量的值变为 true fmt.Println("GoRoutine2 等待标志") for !flag { // 不断循环等待 } // 最终输出并释放锁资源 fmt.Println("GoRoutine 2 从等待中释放") wg.Done() }() // 在主线程中等待 1 秒钟，以便两个 goroutine 开始等待 flag 变量的值 // 然后将 flag 变量设置为 true // 由于两个 goroutine 会同时唤醒并尝试获取锁资源，它们会相互等待 // 最终导致了活锁问题，它们都无法向前推进 fmt.Println("主线程休眠 1 秒") fmt.Println("两个goroutine都应该等待标志") flag = true wg.Wait() fmt.Println("所有 GoRoutines 已完成") }
运行和输出：
[root@workhost temp02]# go run main.go 主线程休眠 1 秒 两个goroutine都应该等待标志 goroutine 2 获取 mu GoRoutine2 等待标志 GoRoutine 2 从等待中释放 goroutine 1 获取 mu goroutine 1 等待标志 goroutine 1 从等待中释放 所有 GoRoutines 已完成
上面的代码存在活锁问题。如果两个goroutine同时等待flag变为true并且都已经获取了锁资源，那么它们就会进入一个死循环并相互等待，无法继续向前推进。
- 代码改造
改造后的代码：
package main import ( "fmt" "runtime" "sync" ) func main() { var wg sync.WaitGroup var mu sync.Mutex var flag bool wg.Add(2) // goroutine 1 go func() { // 先获取锁资源 fmt.Println("goroutine 1 获取 mu") mu.Lock() defer mu.Unlock() // 然后等待 flag 变量的值变为 true fmt.Println("goroutine 1 等待标志") for !flag { runtime.Gosched() // 让出时间片 } // 最终输出并释放锁资源 fmt.Println("goroutine 1 从等待中释放") wg.Done() }() // goroutine 2 go func() { // 先获取锁资源 fmt.Println("goroutine 2 获取 mu") mu.Lock() defer mu.Unlock() // 然后等待 flag 变量的值变为 true fmt.Println("GoRoutine2 等待标志") for !flag { runtime.Gosched() // 让出时间片 } // 最终输出并释放锁资源 fmt.Println("GoRoutine 2 从等待中释放") wg.Done() }() // 在主线程中等待 1 秒钟，以便两个 goroutine 开始等待 flag 变量的值 // 然后将 flag 变量设置为 true // 由于两个 goroutine 会同时唤醒并尝试获取锁资源，它们会相互等待 // 最终导致了活锁问题，它们都无法向前推进 fmt.Println("主线程休眠 1 秒") fmt.Println("两个goroutine都应该等待标志") flag = true wg.Wait() fmt.Println("所有 GoRoutines 已完成") }
改造后的代码在等待flag变量的循环中加入了让出时间片的函数 runtime.Gosched()，这样两个goroutine在等待期间可以放弃时间片，以便其他goroutine可以执行并获得锁资源。这种方式可以有效地减少竞争程度，从而避免了活锁问题。
- 如何避免发生活锁的可能性
在 Go 语言的并发编程中，避免活锁的关键是正确地实现同步机制。以下是一些避免活锁的方法：
- 避免忙等待：使用 sync.Cond 或者 channel 等同步机制来实现等待。这样避免了线程一直占用 CPU 资源而无法取得进展的问题。
- 避免死锁：死锁往往是活锁的前提，因此正确地使用锁和同步机制可以避免死锁，从而避免活锁。
- 减少锁的粒度：尽可能将锁的粒度缩小到最小范围，避免锁住不必要的代码块。
- 采用超时机制：使用 sync.Mutex 的 TryLock() 方法或者使用 select 语句实现等待超时机制，这样可以防止线程无限期等待。
- 合理设计并发模型：合理设计并发模型可以避免竞争和饥饿等问题，进而避免活锁的发生。
