Go基础学习09-多协程资源竞争、sync.Mutex、sync.Cond、chan在多协程对共享变量的资源竞争中的使用

于 2024-09-30 11:12:42 发布
阅读量566 收藏 8
点赞数 13
分类专栏： golang 文章标签： golang java 并发安全 后端 Mutex Cond chan
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45863010/article/details/142651985
版权

文章目录

Go中协程基础小记

协程基础

在Go中，线程被程为goroutine，也有人称其为线程的线程(a thread of thread)。每个线程都有自己的单独的变量如：

PC程序计数器、函数调用栈Stack、一套寄存器Registers。

在Go中协程对应的primitive原语有：

  • start/go：启动/运行一个线程
  • exit：线程退出，一般从某个函数退出/结束执行后，会自动隐式退出
  • stop：停止一个线程，比如向一个没有读者的channel写数据，那么channel阻塞，go可能会运行时暂时停止这个线程
  • resume：恢复原本停止的线程重新执行，需要恢复程序计数器(program counter)、栈指针(stack pointer)、寄存器(register)状态，让处理器继续运行该线程。

为什么需要多协程

依靠多协程达到并发的效果：

  • I/O concurrency：I/O并发。
  • multi-core parallelism：多核并行，提高整体吞吐量。充分利用CPU。
  • convinience：方便，经常有需要异步执行or定时执行的任务，可以通过线程完成。

多协程面临的问题

  • race conditions：多线程会引入竞态条件的场景
    • avoid sharing：避免共享内存以防止竞态条件场景的产生（Go有一个竞态检测器race detector，能够辅助识别代码中的一些竞态条件场景）
    • use locks：让一系列指令变成原子操作
  • coordination：同步协调问题，比如一个线程的执行依赖另一个线程的执行结果等
    • channels：通道允许同时通信和协调
    • condition variables：配合互斥锁使用
  • deadlock：死锁问题，比如在go中简单的死锁场景，一个写线程往channel写数据，但是永远没有读线程从channel读数据，那么写线程被永久阻塞，即死锁，go会抓住这种场景，抛出运行时错误runtime error。

go中还存在一个协程泄漏的问题：参考下面代码示例第四个：channel的使用。

代码演示

存在共享变量的资源竞争

// 定义一个工具类，不具有实际意义。
package main

import "math/rand"

func requestVote() bool {
	intn := rand.Intn(10)
	if intn <= 5 {
		return true
	}
	return false
}

// 基础代码
package main

func main() {

	count := 0
	finished := 0

	for i := 0; i < 10; i++ {
		// 匿名函数，创建共 10 个线程
		go func() {
			vote := requestVote() // 一个内部sleep随机时间，最后返回true的函数，模拟投票
			if vote {
				count++
			}
			finished++
		}()
	}
	for count < 5 && finished != 10 {
		// wait
	}
	if count >= 5 {
		println("received 5+ votes!")
	} else {
		println("lost")
	}
}

使用go自带的资源竞争分析工具：

go run -race xxx.go

执行结果如下：

==================
WARNING: DATA RACE
Write at 0x00c00001c118 by goroutine 9:
  main.main.func1()
      /home/wt/Backend/go/goprojects/src/golearndetail/concurrency/learn01/voteselect.go:20 +0x77

Previous read at 0x00c00001c118 by main goroutine:
  main.main()
      /home/wt/Backend/go/goprojects/src/golearndetail/concurrency/learn01/voteselect.go:25 +0x147

Goroutine 9 (running) created at:
  main.main()
      /home/wt/Backend/go/goprojects/src/golearndetail/concurrency/learn01/voteselect.go:17 +0x71
==================
==================
WARNING: DATA RACE
Write at 0x00c00001c128 by goroutine 9:
  main.main.func1()
      /home/wt/Backend/go/goprojects/src/golearndetail/concurrency/learn01/voteselect.go:22 +0xa4

Previous read at 0x00c00001c128 by main goroutine:
  main.main()
      /home/wt/Backend/go/goprojects/src/golearndetail/concurrency/learn01/voteselect.go:25 +0x164

Goroutine 9 (running) created at:
  main.main()
      /home/wt/Backend/go/goprojects/src/golearndetail/concurrency/learn01/voteselect.go:17 +0x71
==================
received 5+ votes!
==================
WARNING: DATA RACE
Read at 0x00c00001c128 by goroutine 12:
  main.main.func1()
      /home/wt/Backend/go/goprojects/src/golearndetail/concurrency/learn01/voteselect.go:22 +0x91

Previous write at 0x00c00001c128 by goroutine 11:
  main.main.func1()
      /home/wt/Backend/go/goprojects/src/golearndetail/concurrency/learn01/voteselect.go:22 +0xa4

Goroutine 12 (running) created at:
  main.main()
      /home/wt/Backend/go/goprojects/src/golearndetail/concurrency/learn01/voteselect.go:17 +0x71

Goroutine 11 (finished) created at:
  main.main()
      /home/wt/Backend/go/goprojects/src/golearndetail/concurrency/learn01/voteselect.go:17 +0x71
==================
Found 3 data race(s)
exit status 66

通过上述代码运行结果，可以得知存在多个协程的情况下对共享变量count、finished存在资源竞争。

Mutex解决资源竞争

代码示例：

package main

import (
	"sync"
)

func main() {

	count := 0
	finished := 0
	var mu sync.Mutex

	for i := 0; i < 10; i++ {
		// 匿名函数，创建共 10 个线程
		go func() {
			vote := requestVote() // 一个内部sleep随机时间，最后返回true的函数，模拟投票
			// 临界区加锁
			mu.Lock()
			// 推迟到基本block结束后执行，这里即函数执行结束后 自动执行解锁操作。利用defer语言，一般在声明加锁后，立即defer声明推迟解锁
			defer mu.Unlock()
			if vote {
				count++
			}
			finished++
		}()
	}
	for {
		mu.Lock()
		if count > 5 || finished == 10 {
			// 不能在此处解锁，下面仍然需要对count变量进行判断
			//mu.Unlock()
			break
		}
		mu.Unlock()
		// wait
	}
	if count >= 5 {
		println("received 5+ votes!")
	} else {
		println("lost")
	}
	mu.Unlock()
}

运行结果：

wt@wt:~/Backend/go/goprojects/src/golearndetail/concurrency/learn01$ go run -race voteselect_mutex.go utils.go 
received 5+ votes!

使用Mutex后，及时加锁以及解锁，不存在资源竞争。

Mutex+Cond解决资源竞争和CPU空转

代码示例：

package main

import "sync"

func main() {

	count := 0
	finished := 0
	var mu sync.Mutex
	//cond := sync.NewCond(&mu)
	cond := sync.Cond{L: &mu}
	for i := 0; i < 10; i++ {
		// 匿名函数，创建共 10 个线程
		go func() {
			vote := requestVote() // 一个内部sleep随机时间，最后返回true的函数，模拟投票
			// 临界区加锁
			mu.Lock()
			// 推迟到基本block结束后执行，这里即函数执行结束后 自动执行解锁操作。利用defer语言，一般在声明加锁后，立即defer声明推迟解锁
			defer mu.Unlock()
			if vote {
				count++
			}
			finished++

			cond.Broadcast()
		}()
	}
	mu.Lock()
	for count < 5 || finished != 10 {
		// 如果条件不满足，则在制定的条件变量上wait。内部原子地进入sleep状态，并释放与条件变量关联的锁。当条件变量得到满足时，这里内部重新获取到条件变量关联的锁，函数返回。
		cond.Wait()
		// 使用cond.Wait的目的防止CPU空转，使用time.sleep()无法控制合适的休眠时间
	}
	if count >= 5 {
		println("received 5+ votes!")
	} else {
		println("lost")
	}
	mu.Unlock()
}

执行结果：

wt@wt:~/Backend/go/goprojects/src/golearndetail/concurrency/learn01$ go run -race voteselect_mutex_cond.go utils.go 
received 5+ votes!

chan解决资源竞争

代码示例：

package main

func main() {

	count := 0
	finished := 0
	ch := make(chan bool)
	for i := 0; i < 10; i++ {
		// 匿名函数，创建共 10 个线程
		go func() {
			ch <- requestVote()
		}()
	}
	// 这里实现并不完美，如果count >= 5了，主线程不会再监听channel，导致其他还在运行的子线程会阻塞在往channel写数据的步骤。
	// 但是这里主线程退出后子线程们也会被销毁，影响不大。但如果是在一个长期运行的大型工程中，这里就存在泄露线程leaking threads
	for count < 5 && finished != 10 {
		// 主线程在这里等待
		v := <-ch
		if v {
			count++
		}
		finished++
	}
	if count >= 5 {
		println("received 5+ votes!")
	} else {
		println("lost")
	}
}

上述代码中涉及到一个线程泄漏的问题：

在Go语言中，"泄露线程leaking threads"通常指的是goroutine泄漏。Goroutine是Go语言中实现并发的轻量级线程，它们应该是临时的和短暂的。然而，如果一个goroutine因为某些原因无法正常结束，它就会一直运行，从而导致资源无法释放，这就是所谓的goroutine泄漏。
上面代码如果长期运行，由于非缓冲通道没有数据接收者，会导致部分goroutine一直阻塞在向其写数据的操作中，造成线程泄漏。

对于非缓冲通道的理解可以参考我的另一篇博文：
https://blog.csdn.net/weixin_45863010/article/details/142618550?spm=1001.2014.3001.5501
执行结果：

wt@wt:~/Backend/go/goprojects/src/golearndetail/concurrency/learn01$ go run -race voteselect_channel.go utils.go 
received 5+ votes!
快进到失业
关注
专栏目录
秒懂 Golang 中的 条件变量（sync.Cond）
weixin_36593928的博客
12-14 510
通过模拟贴近生活场景的例子，来快速搞懂Go语言中的条件变量（sync.Cond）
Go sync.Cond条件变量的学习
技术能量站
11-09 831
sync.Cond 条件变量用来协调想要访问共享资源的那些 goroutine，当共享资源的状态发生变化的时候，它可以用来通知被互斥锁阻塞的 goroutine。
GO学习之 条件变量 sync.Cond
qq_19283249的博客
12-02 1351
sync.Cond实例的初始化需要一个满足实现了sync.Locker接口的类型实例，通常使用 sync.Mutex。条件变量需要互斥锁来同步临界区数据。各个等待条件成立的 goroutine 在加锁后判断条件是否成立，如果不成立，则调用 sync.Cond 的 Wait 方法进去等待状态。Wait 方法在 goroutine 挂起前会进行 Unlock 操作。
Go语言中sync.Mutex和sync.WaitGroup的用法
浮尘笔记
05-17 677
Go 并发编程中存在的难题：并发编程不像是传统的串行编程，程序的运行存在着很大的不确定性。Go语言中使用sync.Mutex实现互斥锁，使用sync.RWMutex实现读写互斥锁，使用sync.WaitGroup是用来做任务编排的，要解决的就是并发等待的问题。互斥锁 sync.Mutex 是一个结构体类型，属于值传递，因此使用的时候会产生副本。
Golang sync.Cond 简介与用法
Dablelv 的博客专栏。
07-12 6684
Cond 实现了一个条件变量，在 Locker 的基础上增加的一个消息通知的功能，保存了一个通知列表，用来唤醒一个或所有因等待条件变量而阻塞的 Go 程，以此来实现多个 Go 程间的同步。 type Cond struct { // L is held while observing or changing the condition L Locker // contains filt...
Go中协程间通信的方式Sync.Cond
Free雅轩的博客
06-13 1135
在Go中协程间通信的方式有多种，最常用的是channel。如果牵扯多个协程的通知，可以使用sync.Cond。 1. 程序中的通信方式 GO语言中有句名言：“不要用共享内存来通信，而是使用通信来共享内存”。 编程语言中，通信方式分为进程间通信、线程间通信。 1.进程间通信，常用方式： 有名管道 无名管道 信号 共享内存 消息队列 信号灯集 socket 2.线程间通信，常用方式： 信号量 互斥锁 条件变量 对于Go语言来说，Go程序启动之后对外是一个进程，内部包含若干协程，
深入理解 go sync.Cond
rubys007的博客
01-10 994
sync.Cond是一个条件变量，它可以用来协调多个goroutine之间的同步，当条件满足的时候，去通知那些因为条件不满足被阻塞的goroutine继续执行。sync.Cond的接口比较简单，只有WaitSignal和Broadcast三个方法。Wait方法用来阻塞当前goroutine，直到条件满足。调用Wait方法之前，需要先调用L.Lock方法加锁。Signal方法用来唤醒notifyList中的第一个goroutine。Broadcast方法用来唤醒notifyList中的所有。
go并发编程之条件变量sync.Cond实战和原理
qqxhb 资源共享
03-27 426
1. sync.Cond实战 今天简单聊一聊条件变量（conditional variable）。我们常常会把条件变量这个同步工具拿来与互斥锁一起讨论。实际上，条件变量是基于互斥锁的，它必须有互斥锁的支撑才能发挥作用。 条件变量并不是被用来保护临界区和共享资源的，它是用于协调想要访问共享资源的那些线程的。当共享资源的状态发生变化时，它可以被用来通知被互斥锁阻塞的线程。 用Go语言的条件变量在这里的最大优势就是在效率方面的提升。当共享资源的状态不满足条件的时候，想操作它的线程再也不用循环往复地做检查了，只要等
【Go】被遗忘的并发原语——sync.Cond
TomCN0803的博客
02-17 1103
本文介绍了 Go 语言标准库提供的条件变量并发原语`sync.Cond`的一般使用方法，并对比其与 Go 原生的 channel 在不同场景时的优劣。然后我们浅析了`sync.Cond`的源码实现，有助于我们对`sync.Cond`使用方式的理解。
正确理解Go语言中的sync.Cond
禅与代码的艺术
04-13 1125
正确理解Go语言中的sync.Cond
golang_条件变量：sync.Cond作为条件变量的使用
Grayan的博客
03-09 749
场景： 生产者消费者模型中（比如一个有缓存的channel中），生产者进行生产之前去抢锁，如果缓存已满，生产者抢锁无效；消费者进行消费之前去抢锁，如果缓存为空，消费者抢锁无效。所有在抢锁之前需要进行一个判断，称之为条件变量。 sync.Cond的结构： type Cond struct { noCopy noCopy // L is held while observing or chang...
Go同步原语—sync.Cond 详解
weixin_64403990的博客
07-14 383
Go语言标准库中还包含条件变量 sync.Cond，它可以让一组 Goroutine 都在满足特定条件时被唤醒。上述代码同时运行了调用sync.Cond.Broadcast方法后，上述代码会打印出次并结束调用。
go的互斥锁Mutex以及条件变量Condition
weixin_44718747的博客
12-21 708
锁 go中的锁分为两类： 互斥锁Sync.Mutex：特别的如果要实现对象锁的话，可以在定义该对象的结构体时封装一个互斥锁成员,比如 type struct Resource{ resource int lock sync.mutex } 读写锁 sync.RWMutex：读-写、写-读 以及写-写操作互斥，但读-读操作可以并发执行，操作如下： func (*RWMutex) Lock() // 写锁 func (*RWMutex) Unlock() // 解写锁
优化 Go 语言数据打包：性能基准测试与分析
dsgdauigfs的博客
09-24 1153
对于序列化和反序列化在复用内存后，速度的提升非常明显，在同步的操作下，能做到 0 字节分配。异步场景下，使用 sync.Pool 内存固定字节分配（两个返回值在堆上分配）- encode_to：性能最优，几乎没有内存分配，适用于高性能要求的场景。- encode_with_pool：使用内存池优化，显著减少了时间和内存开销，适用于大多数场景。- encode：标准方法，时间和内存开销较高。
GO语言中make与new的区别
lisus2007的专栏
09-25 254
new 可以为任何类型的值开辟内存并返回此值的指针new申请的值均为零值，对创建映射和切处没有意义实际工作中通常使用字面量来创建数组而很少使用new。
golang学习笔记12-函数（一）：定义与使用
技术卷的博客
09-24 417
函数的定义与使用，定义的语法有多种，使用时传递函数的引用，另外也可自定义函数别名
golang学习笔记26-管道（Channel）【重要】
技术卷的博客
09-28 574
本节也是GO核心部分，很重要。介绍了管道的读数据，写数据，关闭，遍历操作，协程和管道如何协同工作，管道的只读/只写声明，select多路复用，for监听管道。
使用apipost工具导入通过swag生成的golang接口文档步骤
最新发布
zhoupenghui168的博客
09-29 260
使用apipost工具导入通过swag生成的golang接口文档步骤
sync.Mutex 在web服务中的使用
06-09
`sync.Mutex` 是 Go 语言中的一个互斥锁，可以用来保护共享资源的访问。在 web 服务中，常常需要保证共享资源的并发访问是安全的，这时就可以使用 `sync.Mutex` 来控制并发访问。 下面是一个示例，展示了如何在 web 服务中使用 `sync.Mutex` 来保证共享变量的安全访问： ```go package main import ( "fmt" "net/http" "sync" ) type Counter struct { mu sync.Mutex // 互斥锁 count int } func (c *Counter) ServeHTTP(w http.ResponseWriter, req *http.Request) { c.mu.Lock() // 加锁 defer c.mu.Unlock() // 解锁 c.count++ fmt.Fprintf(w, "counter = %d\n", c.count) } func main() { var c Counter http.ListenAndServe("localhost:8000", &c) } ``` 在上面的代码中，我们定义了一个结构体 `Counter`，其中包含一个 `sync.Mutex` 类型的互斥锁和一个整型 `count`，表示计数器的值。接着，我们实现了 `ServeHTTP` 方法，该方法使用 `c.mu.Lock()` 加锁并在方法结束时使用 `defer c.mu.Unlock()` 解锁。这样，我们就保证了在任意时刻只有一个 goroutine 能够访问 `Counter` 结构体的共享变量 `count`。最后，我们使用 `http.ListenAndServe` 启动一个 web 服务，监听 `localhost:8000` 地址，并将 `&c` 作为处理器传递给 `ListenAndServe` 方法。 这样，在多个 goroutine 并发访问 `Counter` 结构体的 `count` 变量时，就能够安全地保证并发访问的正确性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值