Golang的锁机制使用及说明

目录
  • 踩坑点
  • 互斥锁 Mutex
  • 读写锁 RWMutex
  • 谨防锁拷贝
  • 查看数据竞争
  • 总结

golang中的锁分为互斥锁、读写锁、原子锁即原子操作。

在 Golang 里有专门的方法来实现锁,就是 sync 包,这个包有两个很重要的锁类型。一个叫 Mutex, 利用它可以实现互斥锁。

一个叫 RWMutex,利用它可以实现读写锁。

  • 全局锁 sync.Mutex,是同一时刻某一资源只能上一个锁,此锁具有排他性,上锁后只能被此线程使用,直至解锁。加锁后即不能读也不能写。全局锁是互斥锁,即 sync.Mutex 是个互斥锁。
  • 读写锁 sync.RWMutex ,将使用者分为读者和写者两个概念,支持同时多个读者一起读共享资源,但写时只能有一个,并且在写时不可以读。理论上来说,sync.RWMutex 的 Lock() 也是个互斥锁。

踩坑点

将上面的结论展开一下,更清晰得说(为避免理解偏差宁可唠叨一些):

  • sync.Mutex 的锁是不可以嵌套使用的。
  • sync.RWMutex 的 mu.Lock() 是不可以嵌套的。
  • sync.RWMutex 的 mu.Lock() 中不可以嵌套 mu.RLock()。(这是个注意的地方)

否则,会 panic fatal error: all goroutines are asleep - deadlock!

var l sync.RWMutex
 
func lockAndRead() { // 可读锁内使用可读锁
    l.RLock()
    defer l.RUnlock()
 
    l.RLock()
    defer l.RUnlock()
}
 
func main() {
    lockAndRead()
    time.Sleep(5 * time.Second)
}

而将 lockAndRead 换为以下三种函数均会造成 panic:

func lockAndRead1() { // 全局锁内使用全局锁
    l.Lock()
    defer l.Unlock()
 
    l.Lock()
    defer l.Unlock()
}
 
func lockAndRead2() { // 全局锁内使用可读锁
    l.Lock()
    defer l.Unlock() // 由于 defer 是栈式执行,所以这两个锁是嵌套结构
 
    l.RLock()
    defer l.RUnlock()
}
 
func lockAndRead3() { // 可读锁内使用全局锁
    l.RLock()
    defer l.RUnlock()
 
    l.Lock()
    defer l.Unlock()
}

互斥锁 Mutex

互斥锁有两个方法:加锁、解锁。

一个互斥锁只能同时被一个 goroutine 锁定,其它 goroutine 将阻塞直到互斥锁被解锁(重新争抢对互斥锁的锁定)。

使用Lock加锁后,不能再进行加锁,只有当对其进行Unlock解锁之后,才能对其加锁。这个很好理解。

  • 如果对一个未加锁的资源进行解锁,会引发panic异常。
  • 可以在一个goroutine中对一个资源加锁,而在另外一个goroutine中对该资源进行解锁。
  • 不要在持有锁的时候做 IO 操作。尽量只通过持有锁来保护 IO 操作需要的资源而不是 IO 操作本身
func (m *Mutex) Lock()
func (m *Mutex) Unlock()

读写锁 RWMutex

读写锁有四个方法:读的加锁、解锁,写的加锁、解锁。

func  (*RWMutex)Lock()
func (*RWMutex)Unlock()

func (*RWMutex)RLock()
func (*RWMutex)RUnlock()

RWMutex的使用主要事项

  • 1、读锁的时候无需等待读锁的结束
  • 2、读锁的时候要等待写锁的结束
  • 3、写锁的时候要等待读锁的结束
  • 4、写锁的时候要等待写锁的结束

谨防锁拷贝

type MyMutex struct {
    count int
    sync.Mutex
}
 
func main() {
    var mu MyMutex
    mu.Lock()
    var mu1 = mu
    mu.count++
    mu.Unlock()
    mu1.Lock()
    mu1.count++
    mu1.Unlock()
    fmt.Println(mu.count, mu1.count)
}

加锁后复制变量,会将锁的状态也复制,所以 mu1 其实是已经加锁状态,再加锁会死锁

查看数据竞争

加上 -race 参数验证数据竞争

以下代码有什么问题,怎么解决?

func main() {
    total, sum := 0, 0
    for i := 1; i <= 10; i++ {
        sum += i
        go func() {
            total += i
        }()
    }
    fmt.Printf("total:%d sum %d", total, sum)
}

该题的第二个考点:data race。

因为存在多 goroutine 同时写 total 变量的问题,所以有数据竞争。

可以加上 -race 参数验证

go run -race main.go
==================
WARNING: DATA RACE
Read at 0x00c0001b4020 by goroutine 8:
  main.main.func1()
      /Users/xuxinhua/main.go:12 +0x57
 
Previous write at 0x00c0001b4020 by main goroutine:
  main.main()
      /Users/xuxinhua/main.go:9 +0x10b
 
Goroutine 8 (running) created at:
  main.main()
      /Users/xuxinhua/main.go:11 +0xe7
==================

正确答案

package main
 
import (
    "sync/atomic"
    "sync"
    "fmt"
)
 
func main() {
    var wg sync.WaitGroup
    var total int64
    sum := 0
    for i := 1; i <= 10; i++ {
        wg.Add(1)
        sum += i
        go func(i int) {
            defer wg.Done()
            atomic.AddInt64(&total, int64(i))
        }(i)
    }
    wg.Wait()
 
    fmt.Printf("total:%d sum %d", total, sum)
}

总结

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • Go并发与锁的两种方式该如何提效详解

    目录 并发不安全的例子 互斥锁 读写锁 小结 总结 并发安全,就是多个并发体在同一段时间内访问同一个共享数据,共享数据能被正确处理. 很多语言的并发编程很容易在同时修改某个变量的时候,因为操作不是原子的,而出现错误计算,比如一个加法运算使用中的变量被修改,而导致计算结果出错,典型的像统计商品库存. 个人建议只要涉及到共享变量统统使用channel,因为channel源码中使用了互斥锁,它是并发安全的. 我们可以不用,但不可以不了解,手中有粮心中不慌. 并发不安全的例子 数组是并发不安全的,在例子

  • Golang分布式锁简单案例实现流程

    其实锁这种东西,都能能不加就不加,锁会导致程序一定程度上退回到串行化,进而降低效率. 首先,看一个案例,如果要实现一个计数器,并且是多个协程共同进行的,就会出现以下的情况: package main import ( "fmt" "sync" ) func main() { numberFlag := 0 wg := new(sync.WaitGroup) for i := 0; i < 200; i++ { wg.Add(1) go func() { def

  • GoLang中的互斥锁Mutex和读写锁RWMutex使用教程

    目录 一.竞态条件与临界区和同步工具 (1)竞态条件 (2)临界区 (3)同步工具 二.互斥量 三.使用互斥锁的注意事项 (1)使用互斥锁的注意事项 (2)使用defer语句解锁 (3)sync.Mutex是值类型 四.读写锁与互斥锁的异同 (1)读/写互斥锁 (2)读写锁规则 (3)解锁读写锁 一.竞态条件与临界区和同步工具 (1)竞态条件 一旦数据被多个线程共享,那么就会产生冲突和争用的情况,这种情况被称为竞态条件.这往往会破坏数据的一致性. 同步的用途有两个,一个是避免多线程在同一时刻操作

  • Go语言实现分布式锁

    目录 1. go实现分布式锁 1.1 redis_lock.go 1.2 retry.go 1.3 lock.lua 1.4 lua_unlock.lua 1.5 refresh.lua 1.6 单元测试 1. go实现分布式锁 通过 golang 实现一个简单的分布式锁,包括锁续约.重试机制.singleflght机制的使用 1.1 redis_lock.go package redis_lock import ( "context" _ "embed" &quo

  • GoLang分布式锁与snowflake雪花算法

    目录 分布式id生成器 分布式锁 负载均衡 go语言在网络服务模块有着得天独厚的优势:传送门详细介绍了涉及到的分布式相关技术. 分布式id生成器 Snowflake(雪花算法),由Twitter提出并开源,可在分布式环境下用于生成唯一ID的算法. 生成的Id是64位(int64)数值类型,包含4部分: 41bit的时间戳(毫秒):一般是相对系统上线时间的毫秒数(可用69年): 5bit的数据中心id+5bit的机器id:表示工作的计算机:实际使用时可根据情况调整两者间的比例: 12bit序列号:

  • Golang的锁机制与使用技巧小结

    目录 1. sync.Mutex详解 2. RWMutex详解 3. sync.Map详解 4. 原子操作 atomic.Value 5. 使用小技巧 1. sync.Mutex详解 sync.Mutex是Go中的互斥锁,通过.lock()方法上锁,.unlock()方法解锁.需要注意的是,因为Go函数值传递的特点,sync.Mutex通过函数传递时,会进行一次拷贝,所以传递过去的锁是一把全新的锁,大家在使用时要注意这一点,另外sync.Mutex是非重入锁,这一点要与Java中的锁区分. ty

  • Golang的锁机制使用及说明

    目录 踩坑点 互斥锁 Mutex 读写锁 RWMutex 谨防锁拷贝 查看数据竞争 总结 golang中的锁分为互斥锁.读写锁.原子锁即原子操作. 在 Golang 里有专门的方法来实现锁,就是 sync 包,这个包有两个很重要的锁类型.一个叫 Mutex, 利用它可以实现互斥锁. 一个叫 RWMutex,利用它可以实现读写锁. 全局锁 sync.Mutex,是同一时刻某一资源只能上一个锁,此锁具有排他性,上锁后只能被此线程使用,直至解锁.加锁后即不能读也不能写.全局锁是互斥锁,即 sync.M

  • golang 自旋锁的实现

    CAS算法(compare and swap) CAS算法是一种有名的无锁算法.无锁编程,即不使用锁的情况下实现多线程之间的变量同步,也就是在没有线程被阻塞的情况下实现变量的同步,所以也叫非阻塞同步(Non-blocking Synchronization).CAS算法涉及到三个操作数 需要读写的内存值V 进行比较的值A 拟写入的新值B 当且仅当 V 的值等于 A时,CAS通过原子方式用新值B来更新V的值,否则不会执行任何操作(比较和替换是一个原子操作).一般情况下是一个自旋操作,即不断的重试.

  • Golang自旋锁的相关介绍

    目录 自旋锁 golang实现自旋锁 可重入的自旋锁和不可重入的自旋锁 自旋锁的其他变种 1. TicketLock 2. CLHLock 3. MCSLock 4. CLHLock 和 MCSLock 自旋锁与互斥锁 总结 自旋锁 获取锁的线程一直处于活跃状态,但是并没有执行任何有效的任务,使用这种锁会造成busy-waiting. 它是为实现保护共享资源而提出的一种锁机制.其实,自旋锁与互斥锁比较类似,它们都是为了解决某项资源的互斥使用.无论是互斥锁,还是自旋锁,在任何时刻,最多只能由一个保

  • Java并发编程之显式锁机制详解

    我们之前介绍过synchronized关键字实现程序的原子性操作,它的内部也是一种加锁和解锁机制,是一种声明式的编程方式,我们只需要对方法或者代码块进行声明,Java内部帮我们在调用方法之前和结束时加锁和解锁.而我们本篇将要介绍的显式锁是一种手动式的实现方式,程序员控制锁的具体实现,虽然现在越来越趋向于使用synchronized直接实现原子操作,但是了解了Lock接口的具体实现机制将有助于我们对synchronized的使用.本文主要涉及以下一些内容: 接口Lock的基本组成成员 可重入锁Re

  • Oracle数据完整性和锁机制简析

    本课内容属于Oracle高级课程范畴,内容略微偏向理论性,但是与数据库程序开发和管理.优化密切相关:另外本课的部分内容在前面章节已经涉及,请注意理论联系实际. 事务 事务(Transaction)从 通讯的角度看:是用户定义的数据库操作序列,这些操作要么全做.要么全不做,是不可分割的一个工作单元.事务控制语句称为TCL,一般包括Commit和Rollback. 事务不是程序,事务和程序分属两个概念.在RDBMS中,一个事务可以有一条SQL语句.一组SQL语句或者整个程序:一个应用程序又通常包含多

  • Java线程并发中常见的锁机制详细介绍

    随着互联网的蓬勃发展,越来越多的互联网企业面临着用户量膨胀而带来的并发安全问题.本文着重介绍了在java并发中常见的几种锁机制. 1.偏向锁 偏向锁是JDK1.6提出来的一种锁优化的机制.其核心的思想是,如果程序没有竞争,则取消之前已经取得锁的线程同步操作.也就是说,若某一锁被线程获取后,便进入偏向模式,当线程再次请求这个锁时,就无需再进行相关的同步操作了,从而节约了操作时间,如果在此之间有其他的线程进行了锁请求,则锁退出偏向模式.在JVM中使用-XX:+UseBiasedLocking pac

  • 深入分析MSSQL数据库中事务隔离级别和锁机制

    锁机制 NOLOCK和READPAST的区别. 1.       开启一个事务执行插入数据的操作. BEGIN TRAN t INSERT INTO Customer SELECT 'a','a' 2.       执行一条查询语句. SELECT * FROM Customer WITH (NOLOCK) 结果中显示"a"和"a".当1中事务回滚后,那么a将成为脏数据.(注:1中的事务未提交) .NOLOCK表明没有对数据表添加共享锁以阻止其它事务对数据表数据的修

  • MySQL锁机制与用法分析

    本文实例讲述了MySQL锁机制与用法.分享给大家供大家参考,具体如下: MySQL的锁机制比较简单,其最显著的特点是不同的存储引擎支持不同的锁机制.比如,MyISAM和MEMORY存储引擎采用的是表级锁:BDB存储引擎采用的是页面锁,但也支持表级锁:InnoDB存储引擎既支持行级锁,也支持表级锁,但默认情况下采用行级锁. MySQL这3种锁的特性可大致归纳如下: (1)表级锁:开销小,加锁快:不会出现死锁:锁定粒度大,发生锁冲突的概率最高,并发度最低. (2)行级锁:开销大,加锁慢:会出现死锁:

  • MySQL InnoDB中的锁机制深入讲解

    写在前面 数据库本质上是一种共享资源,因此在最大程度提供并发访问性能的同时,仍需要确保每个用户能以一致的方式读取和修改数据.锁机制(Locking)就是解决这类问题的最好武器. 首先新建表 test,其中 id 为主键,name 为辅助索引,address 为唯一索引. CREATE TABLE `test` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` int(11) NOT NULL, `address` int(11) NOT NULL, P

随机推荐