什么是死锁：就是在并发程序中，两个或多个线程彼此等待对方完成操作，从而导致它们都被阻塞，并无限期地等待对方完成。这种情况下，程序会卡死，无法继续执行。
什么是活锁：就是程序一直在运行，但是无法取得进展。例如，在某些情况下，多个线程会争夺同一个资源，然后每个线程都会释放资源，以便其他线程可以使用它。但是，如果没有正确的同步，这些线程可能会同时尝试获取该资源，然后再次释放它。这可能导致线程在无限循环中运行，却无法取得进展。
1.编写会发生死锁的代码：
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 将一直等待锁，导致死锁。
2.代码改造
在上面的代码中，可以通过将主 goroutine 中的 defer mu.Unlock() 移到 goroutine 函数中的 mu.Unlock() 后面来解决问题。这样，当 goroutine 获取到锁后，它可以在完成任务后释放锁，以便主 goroutine 可以继续执行。
改造后的代码：
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
3.如何避免死锁
在 Go 语言中，要避免死锁，一定要清楚以下几个规则：
避免嵌套锁：在使用多个锁时，确保它们的嵌套顺序相同。否则，可能会出现循环等待的情况，导致死锁。避免无限等待：如果在获取锁时指定了超时时间，确保在超时后能够处理错误或执行其他操作。避免过度竞争：如果多个协程需要访问相同的资源，请确保它们不会互相干扰。可以使用互斥锁或读写锁等机制来解决竞争问题。使用通道：Go 语言中的通道可以用于协调并发操作。使用通道来传递消息和同步操作，可以避免死锁和竞争问题。确保资源释放：在使用锁或其他资源时，一定要确保它们在使用后得到释放，否则可能会导致死锁。使用 select 语句：在使用通道进行并发操作时，可以使用 select 语句来避免死锁。通过 select 语句选择多个通道中的一个进行操作，可以避免在某个通道被阻塞时出现死锁。
1.编写会发生活锁的代码：
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并且都已经获取了锁资源，那么它们就会进入一个死循环并相互等待，无法继续向前推进。
2.代码改造
改造后的代码：
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可以执行并获得锁资源。这种方式可以有效地减少竞争程度，从而避免了活锁问题。
3.如何避免发生活锁的可能性
在 Go 语言的并发编程中，避免活锁的关键是正确地实现同步机制。以下是一些避免活锁的方法：
避免忙等待：使用 sync.Cond 或者 channel 等同步机制来实现等待。这样避免了线程一直占用 CPU 资源而无法取得进展的问题。避免死锁：死锁往往是活锁的前提，因此正确地使用锁和同步机制可以避免死锁，从而避免活锁。减少锁的粒度：尽可能将锁的粒度缩小到最小范围，避免锁住不必要的代码块。采用超时机制：使用 sync.Mutex 的 TryLock() 方法或者使用 select 语句实现等待超时机制，这样可以防止线程无限期等待。合理设计并发模型：合理设计并发模型可以避免竞争和饥饿等问题，进而避免活锁的发生。
以上就是Go并发编程之死锁与活锁的案例分析的详细内容，更多关于Go死锁 活锁的资料请关注脚本之家其它相关文章！
相关文章
