Go并发编程之死锁与活锁的案例分析(死锁的简单例子java)学到了

随心笔谈9个月前发布 admin
76 0



目录什么是死锁、活锁发生死锁的案例分析发生活锁的案例分析

什么是死锁:就是在并发程序中,两个或多个线程彼此等待对方完成操作,从而导致它们都被阻塞,并无限期地等待对方完成。这种情况下,程序会卡死,无法继续执行。

什么是活锁:就是程序一直在运行,但是无法取得进展。例如,在某些情况下,多个线程会争夺同一个资源,然后每个线程都会释放资源,以便其他线程可以使用它。但是,如果没有正确的同步,这些线程可能会同时尝试获取该资源,然后再次释放它。这可能导致线程在无限循环中运行,却无法取得进展。

1.编写会发生死锁的代码:

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 将一直等待锁,导致死锁。

2.代码改造

在上面的代码中,可以通过将主 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

3.如何避免死锁

在 Go 语言中,要避免死锁,一定要清楚以下几个规则:

避免嵌套锁:在使用多个锁时,确保它们的嵌套顺序相同。否则,可能会出现循环等待的情况,导致死锁。避免无限等待:如果在获取锁时指定了超时时间,确保在超时后能够处理错误或执行其他操作。避免过度竞争:如果多个协程需要访问相同的资源,请确保它们不会互相干扰。可以使用互斥锁或读写锁等机制来解决竞争问题。使用通道:Go 语言中的通道可以用于协调并发操作。使用通道来传递消息和同步操作,可以避免死锁和竞争问题。确保资源释放:在使用锁或其他资源时,一定要确保它们在使用后得到释放,否则可能会导致死锁。使用 select 语句:在使用通道进行并发操作时,可以使用 select 语句来避免死锁。通过 select 语句选择多个通道中的一个进行操作,可以避免在某个通道被阻塞时出现死锁。

1.编写会发生活锁的代码:

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并且都已经获取了锁资源,那么它们就会进入一个死循环并相互等待,无法继续向前推进。

2.代码改造

改造后的代码:

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可以执行并获得锁资源。这种方式可以有效地减少竞争程度,从而避免了活锁问题。

3.如何避免发生活锁的可能性

在 Go 语言的并发编程中,避免活锁的关键是正确地实现同步机制。以下是一些避免活锁的方法:

避免忙等待:使用 sync.Cond 或者 channel 等同步机制来实现等待。这样避免了线程一直占用 CPU 资源而无法取得进展的问题。避免死锁:死锁往往是活锁的前提,因此正确地使用锁和同步机制可以避免死锁,从而避免活锁。减少锁的粒度:尽可能将锁的粒度缩小到最小范围,避免锁住不必要的代码块。采用超时机制:使用 sync.Mutex 的 TryLock() 方法或者使用 select 语句实现等待超时机制,这样可以防止线程无限期等待。合理设计并发模型:合理设计并发模型可以避免竞争和饥饿等问题,进而避免活锁的发生。

以上就是Go并发编程之死锁与活锁的案例分析的详细内容,更多关于Go死锁 活锁的资料请关注脚本之家其它相关文章!

您可能感兴趣的文章:Go select 死锁的一个细节详解Golang并发操作中常见的死锁情形Go 语言中的死锁问题解决

© 版权声明

相关文章