返回顶部
首页 > 资讯 > 后端开发 > GO >Go语言并发编程 互斥锁详情
  • 402
分享到

Go语言并发编程 互斥锁详情

2024-04-02 19:04:59 402人浏览 独家记忆
摘要

目录1、互斥锁Mutex 1.1 Mutex介绍 1.2 Mutex使用实例2、读写锁RWMutex 2.1 RWMutex介绍2.2 RWMutex使用实例1、互斥锁Mutex

1、互斥锁Mutex

1.1 Mutex介绍

Go 语言的同步工具主要由 sync 包提供,互斥锁 (Mutex) 与读写锁 (RWMutex) 就是sync 包中的方法。

互斥锁可以用来保护一个临界区,保证同一时刻只有一个 goroutine 处于该临界区内。主要包括锁定(Lock方法)和解锁(Unlock方法)两个操作,首先对进入临界区的goroutine进行锁定,离开时进行解锁。

使用互斥锁 (Mutex)时要注意以下几点:

  • 不要重复锁定互斥锁,否则会阻塞,也可能会导致死锁(deadlock);
  • 要对互斥锁进行解锁,这也是为了避免重复锁定;
  • 不要对未锁定或者已解锁的互斥锁解锁;
  • 不要在多个函数之间直接传递互斥锁,sync.Mutex类型属于值类型,将它传给一个函数时,会产生一个副本,在函数中对锁的操作不会影响原锁

总之,一个互斥锁只用来保护一个临界区,加锁后记得解锁,对于每一个锁定操作,都要有且只有一个对应的解锁操作,也就是加锁和解锁要成对出现,最保险的做法时使用defer语句解锁。

1.2 Mutex使用实例

下面的代码模拟取钱和存钱操作:


package main

import (
 "flag"
 "fmt"
 "sync"
)

var (
    mutex   sync.Mutex
    balance int
    protecting uint  // 是否加锁
    sign = make(chan struct{}, 10) //通道,用于等待所有goroutine
)

// 存钱
func deposit(value int) {
    defer func() {
        sign <- struct{}{}
    }()

    if protecting == 1 {
        mutex.Lock()
        defer mutex.Unlock()
    }

    fmt.Printf("余额: %d\n", balance)
    balance += value
    fmt.Printf("存 %d 后的余额: %d\n", value, balance)
    fmt.Println()

}

// 取钱
func withdraw(value int) {
    defer func() {
        sign <- struct{}{}
    }()
    
    if protecting == 1 {
        mutex.Lock()
        defer mutex.Unlock()
    }

    fmt.Printf("余额: %d\n", balance)
    balance -= value
    fmt.Printf("取 %d 后的余额: %d\n", value, balance)
    fmt.Println()

}

func main() {
    
    for i:=0; i < 5; i++ {
        go withdraw(500) // 取500
        go deposit(500)  // 存500
    }

    for i := 0; i < 10; i++ {
  <-sign
 }
    fmt.Printf("当前余额: %d\n", balance)
}

func init() {
    balance = 1000 // 初始账户余额为1000
    flag.UintVar(&protecting, "protecting", 0, "是否加锁,0表示不加锁,1表示加锁")
}



上面的代码中,使用了通道来让主 goroutine 等待其他 goroutine 运行结束,每个子goroutine在运行结束之前向通道发送一个元素,主 goroutine 在最后从这个通道接收元素,接收次数与子goroutine个数相同。接收完后就会退出主goroutine。

代码使用协程实现多次(5次)对一个账户进行存钱和取钱的操作,先来看不加锁的情况

余额: 1000
存 500 后的余额: 1500

余额: 1000
取 500 后的余额: 1000

余额: 1000
存 500 后的余额: 1500

余额: 1000
取 500 后的余额: 1000

余额: 1000
存 500 后的余额: 1500

余额: 1000
取 500 后的余额: 1000

余额: 1000
取 500 后的余额: 500

余额: 1000
存 500 后的余额: 1000

余额: 1000
取 500 后的余额: 500

余额: 1000
存 500 后的余额: 1000

当前余额: 1000

可以看到出现了混乱,比如第二次1000的余额取500后还是1000,这种对同一资源的竞争出现了竞态条件(Race Condition)。

下面来看加锁的执行结果:

余额: 1000
取 500 后的余额: 500

余额: 500
存 500 后的余额: 1000

余额: 1000
取 500 后的余额: 500

余额: 500
存 500 后的余额: 1000

余额: 1000
取 500 后的余额: 500

余额: 500
存 500 后的余额: 1000

余额: 1000
存 500 后的余额: 1500

余额: 1500
取 500 后的余额: 1000

余额: 1000
取 500 后的余额: 500

余额: 500
存 500 后的余额: 1000

当前余额: 1000
加锁后就正常了。

下面介绍更细化的互斥锁:读/写互斥锁RWMutex

2、读写锁RWMutex

2.1 RWMutex介绍

读/写互斥锁RWMutex包含了读锁和写锁,分别对共享资源的“读操作”和“写操作”进行保护。sync.RWMutex类型中的Lock方法和Unlock方法分别用于对写锁进行锁定和解锁,而它的RLock方法和RUnlock方法则分别用于对读锁进行锁定和解锁。

有了互斥锁Mutex,为什么还需要读写锁呢?因为在很多并发操作中,并发读取占比很大,写操作相对较少,读写锁可以并发读取,这样可以提供服务性能。读写锁具有以下特征:

读写锁 读锁 写锁
读锁 Yes No
写锁 No No

也就是说:

  • 如果某个共享资源受到读锁和写锁保护时,其它goroutine不能进行写操作。换句话说就是读写操作和写写操作不能并行执行,也就是读写互斥;
  • 受读锁保护时,可以同时进行多个读操作。

在使用读写锁时,还需要注意:

  • 不要对未锁定的读写锁解锁;
  • 对读锁不能使用写锁解锁
  • 对写锁不能使用读锁解锁

2.2 RWMutex使用实例

改写前面的取钱和存钱操作,添加查询余额的方法:


package main

import (
 "fmt"
 "sync"
)

// account 代表计数器。
type account struct {
 num uint         // 操作次数
 balance int   // 余额
 rwMu  *sync.RWMutex // 读写锁
}

var sign = make(chan struct{}, 15) //通道,用于等待所有goroutine

// 查看余额:使用读锁
func (c *account) check() {
 defer func() {
        sign <- struct{}{}
    }()
 c.rwMu.RLock()
 defer c.rwMu.RUnlock()
 fmt.Printf("%d 次操作后的余额: %d\n", c.num, c.balance)
}

// 存钱:写锁
func (c *account) deposit(value int) {
 defer func() {
        sign <- struct{}{}
    }()
    c.rwMu.Lock()
 defer c.rwMu.Unlock() 

 fmt.Printf("余额: %d\n", c.balance)   
 c.num += 1
    c.balance += value
    fmt.Printf("存 %d 后的余额: %d\n", value, c.balance)
    fmt.Println() 
}

// 取钱:写锁
func (c *account) withdraw(value int) {
    defer func() {
        sign <- struct{}{}
    }()
 c.rwMu.Lock()
 defer c.rwMu.Unlock()   
 fmt.Printf("余额: %d\n", c.balance)     
 c.num += 1
    c.balance -= value
 fmt.Printf("取 %d 后的余额: %d\n", value, c.balance)
    fmt.Println()  
}


func main() {
 c := account{0, 1000, new(sync.RWMutex)}

 for i:=0; i < 5; i++ {
        go c.withdraw(500) // 取500
        go c.deposit(500)  // 存500
  go c.check()
    }

    for i := 0; i < 15; i++ {
  <-sign
 }
 fmt.Printf("%d 次操作后的余额: %d\n", c.num, c.balance)

}

执行结果:

余额: 1000
取 500 后的余额: 500

1 次操作后的余额: 500
1 次操作后的余额: 500
1 次操作后的余额: 500
1 次操作后的余额: 500
1 次操作后的余额: 500
余额: 500
存 500 后的余额: 1000

余额: 1000
取 500 后的余额: 500

余额: 500
存 500 后的余额: 1000

余额: 1000
存 500 后的余额: 1500

余额: 1500
取 500 后的余额: 1000

余额: 1000
取 500 后的余额: 500

余额: 500
存 500 后的余额: 1000

余额: 1000
取 500 后的余额: 500

余额: 500
存 500 后的余额: 1000

10 次操作后的余额: 1000

读写锁和互斥锁的不同之处在于读写锁把对共享资源的读操作和写操作分开了,可以实现更复杂的访问控制。

总结:

读写锁也是一种互斥锁,它是互斥锁的扩展。在使用时需要注意:

  • 加锁后一定要解锁
  • 不要重复加锁或者解锁
  • 不解锁未锁定的锁
  • 不要传递互斥锁

到此这篇关于Go语言并发编程 互斥锁详情的文章就介绍到这了,更多相关Go语言并发编程 互斥锁内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网!

您可能感兴趣的文档:

--结束END--

本文标题: Go语言并发编程 互斥锁详情

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

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

猜你喜欢
  • Go语言并发编程 互斥锁详情
    目录1、互斥锁Mutex 1.1 Mutex介绍 1.2 Mutex使用实例2、读写锁RWMutex 2.1 RWMutex介绍2.2 RWMutex使用实例1、互斥锁Mutex ...
    99+
    2024-04-02
  • Go语言并发编程之互斥锁Mutex和读写锁RWMutex
    目录一、互斥锁Mutex1、Mutex介绍2、Mutex使用实例二、读写锁RWMutex1、RWMutex介绍2、RWMutex使用实例在并发编程中,多个Goroutine访问同一块...
    99+
    2024-04-02
  • 一文掌握Go语言并发编程必备的Mutex互斥锁
    目录1. Mutex 互斥锁的基本概念2. Mutex 互斥锁的基本用法3. Mutex 互斥锁的底层实现3.1 等待队列3.2 锁状态4. Mutex 互斥锁的注意事项4.1 不要...
    99+
    2023-05-18
    Go语言 Mutex互斥锁 Go语言 Mutex Go Mutex互斥锁
  • Go语言的互斥锁的详细使用
    目录前言Go语言互斥锁设计实现mutex介绍Lock加锁初始化状态自旋抢锁准备期望状态通过CAS操作更新期望状态解锁非阻塞加锁总结前言 当提到并发编程、多线程编程时,都会在第一时间想...
    99+
    2024-04-02
  • Go语言线程安全之互斥锁与读写锁
    目录一、互斥锁是什么?1.概念2.未加锁3.加锁之后二、读写锁【效率革命】1.为什么读写锁效率高2.使用方法三、sync.once1.sync.once产生背景2.sync.once...
    99+
    2024-04-02
  • Go语言互斥锁与读写锁实例分析
    这篇“Go语言互斥锁与读写锁实例分析”文章的知识点大部分人都不太理解,所以小编给大家总结了以下内容,内容详细,步骤清晰,具有一定的借鉴价值,希望大家阅读完这篇文章能有所收获,下面我们一起来看看这篇“Go语言互斥锁与读写锁实例分析”文章吧。前...
    99+
    2023-06-29
  • GO语言协程互斥锁Mutex和读写锁RWMutex用法实例详解
    sync.Mutex Go中使用sync.Mutex类型实现mutex(排他锁、互斥锁)。在源代码的sync/mutex.go文件中,有如下定义: // A Mutex is a m...
    99+
    2024-04-02
  • GO语言协程互斥锁Mutex和读写锁RWMutex怎么用
    本文小编为大家详细介绍“GO语言协程互斥锁Mutex和读写锁RWMutex怎么用”,内容详细,步骤清晰,细节处理妥当,希望这篇“GO语言协程互斥锁Mutex和读写锁RWMutex怎么用”文章能帮助大家解决疑惑,下面跟着小编的思路慢慢深入,一...
    99+
    2023-06-30
  • 【漫画】JAVA并发编程 J.U.C Lock包之ReentrantLock互斥锁
    在如何解决原子性问题的最后,我们卖了个关子,互斥锁不仅仅只有synchronized关键字,还可以用什么来实现呢? J.U.C包中还提供了一个叫做Locks的包,我好歹英语过了四级,听名字我就能马上大声的说:Locks包必然也可以...
    99+
    2018-12-24
    【漫画】JAVA并发编程 J.U.C Lock包之ReentrantLock互斥锁
  • Go语言并发编程中的锁应用
    Go语言是一种开源编程语言,最初由Google开发,旨在提升程序员的效率和系统的性能。Go语言支持并发编程,也就是同时执行多个任务,其中使用锁是一种常见的方式来保证并发安全。在本文中,...
    99+
    2024-04-02
  • Go语言互斥锁Mutex和读写锁RWMutex的用法
    这篇文章主要介绍“Go语言互斥锁Mutex和读写锁RWMutex的用法”,在日常操作中,相信很多人在Go语言互斥锁Mutex和读写锁RWMutex的用法问题上存在疑惑,小编查阅了各式资料,整理出简单好用的操...
    99+
    2024-04-02
  • 熟悉 Go 语言中的锁和互斥机制
    Go 语言是一种非常流行的编程语言,尤其在并发编程方面表现尤为出色。而当我们在处理并发编程的时候,锁和互斥机制是不可避免的。本文将介绍 Go 语言中的锁和互斥机制。 一、互斥锁 互斥锁...
    99+
    2024-04-02
  • Go语言原子操作及互斥锁的区别
    目录增或减比较并交换(Compare And Swap)载入与存储交换原子值原子操作与互斥锁的区别原子操作就是不可中断的操作,外界是看不到原子操作的中间状态,要么看到原子操作已...
    99+
    2022-06-07
    GO 互斥 原子 原子操作 互斥锁 go语言
  • Go语言并发编程 sync.Once
    sync.Once用于保证某个动作只被执行一次,可用于单例模式中,比如初始化配置。我们知道init()函数也只会执行一次,不过它是在main()函数之前执行,如果想要在代码执行过程中...
    99+
    2024-04-02
  • Go语言底层原理互斥锁的实现原理
    目录Go 互斥锁的实现原理?概念使用场景底层实现结构操作加锁解锁Go 互斥锁正常模式和饥饿模式的区别?正常模式(非公平锁)饥饿模式(公平锁)Go 互斥锁允许自旋的条件?Go 互斥锁的...
    99+
    2024-04-02
  • Go语言文档解析:sync.Mutex函数实现互斥锁
    Go语言是一种开源的编程语言,其中使用了并发编程模型来处理多个任务之间的交替执行。在并发编程中,往往涉及到多个协程或线程同时访问共享资源的情况,此时就需要使用互斥锁来保证资源的独占性,避免竞态条件的发生。在Go语言中,提供了sync包来实现...
    99+
    2023-11-04
    Go语言 文档解析 syncMutex
  • Go语言并发编程指南
    Go语言是一种开源的编程语言,它被设计用于构建简单、可靠和高效的软件。其中最显著的特点之一便是其强大的并发编程能力。通过Go语言的并发特性,可以更好地利用多核处理器,实现高效的并行处理...
    99+
    2024-04-02
  • go语言限制协程并发数的方案详情
    目录前言一、使用带缓冲的通道限制并发数1.1方案详情1.2评估总结2.2评估总结其它前言 在使用协程并发处理某些任务时, 其并发数量往往因为各种因素的限制不能无限的增大. 例如网络请...
    99+
    2024-04-02
  • Go语言原子操作及互斥锁的区别是什么
    本篇内容介绍了“Go语言原子操作及互斥锁的区别是什么”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!原子操作就是不可中断的操作,外界是看不到原...
    99+
    2023-06-22
  • python实现多进程并发控制Semaphore与互斥锁LOCK
    一、了解锁 应用场景举例描述: Lock 互斥锁:举例说明有三个同事同时需要上厕所,但是只有一间厕所,将同事比作进程,多个进程并打抢占一个厕所,我们要保证顺序优先, 一个个来,那么就必须串行,先到先得,有人使用了,...
    99+
    2022-06-02
    python 多进程Semaphore与LOCK python 多进程并发控制Semaphore Python互斥锁LOCK
软考高级职称资格查询
编程网,编程工程师的家园,是目前国内优秀的开源技术社区之一,形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容,为IT开发者提供了一个发现、使用、并交流开源技术的平台。
  • 官方手机版

  • 微信公众号

  • 商务合作