首页 > 资讯 > 后端开发 > GO >解析Golang中的锁竞争问题

734

分享到

解析Golang中的锁竞争问题

2024-04-02 19:04:59 734人浏览薄情痞子

摘要

当我们打印错误的时候使用锁可能会带来意想不到的结果。我们看下面的例子： package main import ( "fmt" "sync" ) type Coursewa

当我们打印错误的时候使用锁可能会带来意想不到的结果。

我们看下面的例子：

package main

import (
	"fmt"
	"sync"
)

type Courseware struct {
	mutex sync.RWMutex
	Id    int64
	Code   string
	Duration int
}

func (c *Courseware) UpdateDuration(duration int) error {
	c.mutex.Lock() // 1
	defer c.mutex.Unlock()

	if duration < 60 {
		return fmt.Errorf("课件时长必须大于等于60秒： %v", c) // 2
	}

	c.Duration = duration
	return nil
}

// 3
func (c *Courseware) String() string {
	c.mutex.RLock()
	defer c.mutex.RUnlock()
	return fmt.Sprintf("id %d, duration %d", c.Id, c.Duration)
}


func main() {
	c := &Courseware{}
	fmt.Println(c.UpdateDuration(0))
}

上面的代码看起来貌似没有什么问题，但是却会导致死锁：

更新课件时长的时候上锁，避免出现数据竞争
判断如果时长小于60秒的话，就报错。但是注意这里fmt.Errorf打印结构c会调用String()方法
我们看String方法里面，又使用了读锁，避免读取的时候数据被更新

因为对临界资源重复上锁，所以导致了死锁的问题。解决办法也很简单：

把锁放到错误判断之后：

func (c *Courseware) UpdateDuration(duration int) error {

	if duration < 60 {
		return fmt.Errorf("课件时长必须大于等于60秒： %v", c) // 2
	}

  c.mutex.Lock() 
	defer c.mutex.Unlock()

	c.Duration = duration
	return nil
}

不使用String方法，避免重复上锁：

package main

import (
	"fmt"
	"sync"
)

type Courseware struct {
	mutex sync.RWMutex
	Id    int64
	Code   string
	Duration int
}

func (c *Courseware) UpdateDuration(duration int) error {
	c.mutex.Lock() 
	defer c.mutex.Unlock()

	if duration < 60 {
		return fmt.Errorf("课件时长必须大于等于60秒： %d， id: %d", c.Duration, c.Id) // 打印放在一个锁里面也能保证安全
	}

	c.Duration = duration
	return nil
}


func main() {
	c := &Courseware{}
	fmt.Println(c.UpdateDuration(0))
}

Go  run  10.go
课件时长必须大于等于60秒： 0， id: 0

我们再看一个切片的例子：

package main

import (
	"fmt"
)


func main() {
	s := make([]int, 1)

	go func() {
		s1 := append(s, 1)
		fmt.Println(s1)
	}()

	go func() {
		s2 := append(s, 1)
		fmt.Println(s2)
	}()
}

我们初始化了一个长度为1，容量为1的切片，然后分别在2个协程里面调用append往切片追加元素。这种情况会导致数据竞争么？

答案是不会。在其中一个协程里面，当我们append元素的时候，因为s的容量为1，所以底层会复制一个新的数组；同样另一个协程也是如此。

go  run -race 10.go
[0 1]
[0 1]

注意：这里的关键就是，两个协程是否会同时访问一个内存空间，这时导致数据竞争的关键。

我们稍微修改下上面的例子：

package main

import (
	"fmt"
)


func main() {
	s := make([]int, 1, 10) // 1

	go func() {
		s1 := append(s, 1)
		fmt.Println(s1)
	}()

	go func() {
		s2 := append(s, 1)
		fmt.Println(s2)
	}()
}

我们给s加了一个足够大的容量

go  run -race 10.go
[0 1]
==================
WARNING: DATA RACE
Write at 0x00c0000c0008 by goroutine 8:
  main.main.func2()
...

可以看到这就产生了数据竞争的问题。因为s的容量足够大，所以两个协程有可能操作同一个底层数组的同一块内存。

解决办法也很简单，重新copy一个s就行了。

下面我们继续看一个map的例子：

package main

import (
	"strconv"
	"sync"
	"time"
)

// 1
type User struct {
	mu       sync.RWMutex
	online map[string]bool
}

// 2
func (u *User) AddOnline(id string) {
	u.mu.Lock()
	u.online[id] = true
	u.mu.Unlock()
}

// 3
func (u *User) AllOnline() int {
	u.mu.RLock()
	online := u.online // 4
	u.mu.RUnlock()

	sum := 0
	for _, o := range online { // 5
		if o {
			sum++
		}
	}
	return sum
}

func main() {
	u := &User{}
	u.online = make(map[string]bool)

	go func() {
		for i := 0; i < 10000; i++ {
			u.AddOnline("userid" + strconv.Itoa(i))
		}
	}()

	go func() {
		for i := 0; i < 10000; i++ {
			u.AllOnline()
		}
	}()

	time.Sleep(time.Second)
}

我们有一个用户的机构，里面有个online字段是一个map，里面保存了在线的用户信息
我们有一个添加在线用户的方法AddOnline，方法里面使用了锁，是因为map是并发不安全的
我们还有一个统计所有在线用户的方法AllOnline
在AllOnline中，我们访问u.online的map，我们加上了读锁。这里的想法是访问当前在线用户的map，并赋值给online，然后释放读锁
遍历赋值的online查出在线用户的数量

可能我们觉得这个是没问题的，但是当我们运行程序的时候会发现这里存在数据竞争：

go  run -race 10.go
==================
WARNING: DATA RACE
Write at 0x00c0000a0060 by goroutine 6:
  runtime.mapassign_faststr()

...

==================
fatal error: concurrent map iteration and map write

这是因为，在map内部，是hmap结构，主要包含元数据（例如，计数器）和引用数据桶的指针。因此，online := u.online 不会复制实际数据，而是复制的指针，实际操作的还是同一片内存。

解决这个问题也不难：

我们可以把锁的范围扩大，像下面这样：

func (u *User) AllOnline() int {
	u.mu.RLock()
	defer u.mu.RUnlock()
	online := u.online

	sum := 0
	for _, o := range online {
		if o {
			sum++
		}
	}
	return sum
}

另一种方法就是复制一个副本出来，像上面我们说的切片一样：

func (u *User) AllOnline() int {
	u.mu.RLock()
	online := make(map[string]bool, len(u.online))
	for s, b := range u.online {
		online[s] = b
	}
	u.mu.RUnlock()

	sum := 0
	for _, o := range online {
		if o {
			sum++
		}
	}
	return sum
}

上面的例子中我们使用了*User定义了2个方法：

func (u *User) AddOnline(id string) {
	u.mu.Lock()
	u.online[id] = true
	u.mu.Unlock()
}

func (u *User) AllOnline() int {
	u.mu.RLock()
	online := make(map[string]bool, len(u.online))
	for s, b := range u.online {
		online[s] = b
	}
	u.mu.RUnlock()

	sum := 0
	for _, o := range online {
		if o {
			sum++
		}
	}
	return sum
}

我现在我们稍微修改下上面的列子：

package main

import (
	"strconv"
	"sync"
	"time"
)

type User struct {
	mu       sync.RWMutex
	online map[string]bool
}

func (u User) AddOnline(id string) {
	u.mu.Lock()
	u.online[id] = true
	u.mu.Unlock()
}

func (u User) AllOnline() int {
	u.mu.RLock()
	online := make(map[string]bool, len(u.online))
	for s, b := range u.online {
		online[s] = b
	}
	u.mu.RUnlock()

	sum := 0
	for _, o := range online {
		if o {
			sum++
		}
	}
	return sum
}

func main() {
	u := User{}
	u.online = make(map[string]bool)

	go func() {
		for i := 0; i < 10000; i++ {
			u.AddOnline("userid" + strconv.Itoa(i))
		}
	}()

	go func() {
		for i := 0; i < 10000; i++ {
			u.AllOnline()
		}
	}()

	time.Sleep(time.Second)
}

现在我们直接使用User结构体定义这两个方法，但是当我们执行程序的时候，报了数据竞争的错误：

go  run -race 10.go
==================
WARNING: DATA RACE
Read at 0x00c00011e060 by goroutine 7:
  main.User.AllOnline()

这个又是什么原因造成的呢？这是因为，当我门使用User作为参数时，直接复制了User的副本，因此sync.RWMutex也会被复制。

因为锁被复制了，所以对于同一个临界资源，处于不同锁的读写操作可以同时访问。

到此这篇关于golang中的锁竞争问题的文章就介绍到这了,更多相关go锁竞争内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

Go语言（Golang）教程

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: 解析Golang中的锁竞争问题

本文链接: https://www.lsjlt.com/news/121310.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

解析Golang中的锁竞争问题

当我们打印错误的时候使用锁可能会带来意想不到的结果。我们看下面的例子： package main import ( "fmt" "sync" ) type Coursewa...

99+

2024-04-02
MySQL中的锁竞争问题如何解决

MySQL中的锁竞争问题可以通过以下方式解决：优化查询语句：尽量避免长时间持有锁的操作，可以通过优化查询语句、建立合适的索引等...

99+

2024-04-30

MySQL
golang函数并发缓存的锁竞争分析

go 中函数并发缓存存在锁竞争问题，导致性能下降，甚至程序崩溃。可以使用 pprof 或 go tool trace 分析锁竞争。一种解决方法是在缓存函数中加锁，确保一次只有一个 gor...

99+

2024-05-01

锁竞争并发缓存 golang
多核编程中的锁竞争现象分析

这篇文章主要介绍“多核编程中的锁竞争现象分析”，在日常操作中，相信很多人在多核编程中的锁竞争现象分析问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”多核编程中的锁竞争现象分析”...

99+

2024-04-02
PHP Session条件竞争问题怎么解决

这篇文章主要介绍“PHP Session条件竞争问题怎么解决”的相关知识，小编通过实际案例向大家展示操作过程，操作方法简单快捷，实用性强，希望这篇“PHP Session条件竞争问题怎么解决”文章能帮助大家解决问题。PH...

99+

2023-07-04
Go语言中资源竞争问题怎么解决

这篇“Go语言中资源竞争问题怎么解决”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“Go语言中资源竞争问题怎么解决”文章吧。场...

99+

2023-07-05
Golang和C语言的竞争关系分析

Golang和C语言的竞争关系分析近年来，Golang (Go) 和C语言一直是软件开发领域中备受关注的两种编程语言。Golang作为一种新兴的语言，具有优秀的并发性能和简洁的语法，...

99+

2024-03-05

golang c语言竞争 golang (go)
解析golang中的并发安全和锁问题

1. 并发安全 package main import ( "fmt" "sync" ) var ( sum int wg sync.Wa...

99+

2024-04-02
Go语言中如何解决并发资源竞争的问题？

Go语言中如何解决并发资源竞争的问题？在并发编程中，资源竞争是一种常见的问题，指的是多个goroutine同时访问、读写共享的资源导致的不确定行为。Go语言提供了一些机制来解决并发资源竞争的问题，本文将介绍一些常用的方法，并给出具体的代码示...

99+

2023-10-22

信号量（Semaphore）互斥锁（Mutex）通道（Channel）
Go语言中如何解决并发资源竞争的问题

在Go语言中，可以使用以下几种方法来解决并发资源竞争的问题：1. 互斥锁（Mutex）：使用`sync.Mutex`类型来创建一个互...

99+

2023-10-09

Go语言
Golang函数的数据竞争解决方法详解

在并发编程中，数据竞争是一个常见的问题。由于Golang是一门并发编程的语言，因此数据竞争在Golang中也是一个非常重要的话题。在本文中，我们将详细讨论Golang函数的数据竞争解决方法。什么是数据竞争？在Golang中，数据竞争指的是多...

99+

2023-05-17

Golang 解决方法数据竞争
一文聊聊Go语言中资源竞争问题

我们都知道，在并发编程中，线程安全是非常重要的。接下来我们就假定一个场景，复现一下线程不安全的情况，再聊聊如何在Go中解决场景我们现在需要对1~100求他们的阶乘，并将结果放到一个map中1! = 1 = 1 2! = 1 * 2 = 2 ...

99+

2023-05-14

Golang go语言 Go 后端
深度解析Golang常用库：提升你的项目竞争力

Golang常用库全解析：让你的项目更具竞争力引言：Golang是一门简洁、高效的编程语言，因其出色的并发性能和轻量级的开发风格而备受开发者青睐。然而，作为一种相对年轻的语言，Golang在标准库方面仍然有...

99+

2024-01-18

Golang 竞争力常用库
Java编程中的并发索引算法：解决多线程竞争的问题？

在Java编程中，多线程并发是一个常见的问题。在多个线程同时访问共享资源时，由于访问的顺序和时间不确定，就会产生竞争的问题。这种竞争会导致程序出现意想不到的结果，甚至引发严重的错误。为了解决这个问题，Java提供了一些并发算法来帮助开发者...

99+

2023-06-30

索引编程算法并发
ASP IDE并发存储：如何解决数据竞争问题？

在ASP IDE中，我们经常会遇到多个用户同时访问同一份数据的情况。这时候如果不处理好并发存储问题，就会导致数据竞争，进而影响系统的稳定性和可靠性。本文将介绍ASP IDE中并发存储的问题以及如何解决数据竞争问题。并发存储问题在A...

99+

2023-09-07

ide 并发存储
go语言中的缓存和并发处理：如何避免容器的竞争和死锁问题？

Go语言是一门非常强大的编程语言，它特别擅长处理并发。在Go语言中，我们可以使用缓存来提高程序的运行效率，同时也可以通过并发处理来避免容器的竞争和死锁问题。本文将为你详细介绍Go语言中的缓存和并发处理，并提供一些演示代码。一、什么是缓存？...

99+

2023-11-07

缓存并发容器
标题之星：让你的标题在竞争中闪耀

创建引人注目的标题对于 SEO 至关重要，它可以帮助你提高搜索结果中的排名并吸引更多流量。以下是一些步骤，可让你写出可让你的标题在竞争中脱颖而出的标题： 1. 研究在撰写标题之前，请对目标受众进行研究。确定你的受众在搜索什么，并使用这些...

99+

2024-03-05

标题优化、SEO、标题写作、搜索引擎优化
golang函数管道通信中的竞争条件规避

解决函数管道通信中的竞争条件：使用并发安全类型（sync.mutex）同步对管道数据的访问。为管道添加缓冲，暂时存储数据，防止 goroutine 之间的数据争用。限制同时执行函数管道的...

99+

2024-05-03

管道通信竞争条件 golang 数据丢失
解析golang中的mahonia乱码问题

golang是一门非常优秀的编程语言，支持多种平台和架构。在使用golang进行中文编程时，我们常常遇到字符编码的问题，其中最常见的问题就是乱码。而golang内置的mahonia库就是一款解决字符编码问题的工具。然而，在实际使用过程中，我...

99+

2023-05-14
Go语言中的数据竞争模式详解

目录前言Go在goroutine中通过引用来透明地捕获自由变量切片会产生难以诊断的数据竞争并发访问Go内置的、不安全的线程映射会导致频繁的数据竞争 ...

99+

2024-04-02