Go并发编程之死锁与活锁是什么

发布时间:2023-05-05 14:31:12 作者:iii
来源:亿速云 阅读:254

本文小编为大家详细介绍“Go并发编程之死锁与活锁是什么”,内容详细,步骤清晰,细节处理妥当,希望这篇“Go并发编程之死锁与活锁是什么”文章能帮助大家解决疑惑,下面跟着小编的思路慢慢深入,一起来学习新知识吧。

什么是死锁、活锁

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

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

发生死锁的案例分析

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 语言中,要避免死锁,一定要清楚以下几个规则:

发生活锁的案例分析

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 语言的并发编程中,避免活锁的关键是正确地实现同步机制。以下是一些避免活锁的方法:

读到这里,这篇“Go并发编程之死锁与活锁是什么”文章已经介绍完毕,想要掌握这篇文章的知识点还需要大家自己动手实践使用过才能领会,如果想了解更多相关内容的文章,欢迎关注亿速云行业资讯频道。

推荐阅读:
  1. vscode如何配置go开发环境
  2. 怎么用Go判断元素是否在切片中

免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。

go

上一篇:JavaScript怎么获取最近7天的日期

下一篇:Python怎么用PsUtil实现实时监控系统状态

相关阅读

您好,登录后才能下订单哦!

密码登录
登录注册
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》