【go基础】11.atomic与锁 Mutex, RWMutex

已于 2024-03-24 17:01:24 修改
阅读量855 收藏 16
点赞数 11
分类专栏： go语言原理 文章标签： golang 开发语言 后端
于 2024-03-22 22:35:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lixiaonan0318/article/details/136953581
版权

目录

如何保证线程安全

几种锁

1、常用的锁

2、乐观锁与悲观锁

3、死锁

Mutex互斥锁

1、Mutex结构

2、自旋的goroutine

3、锁的两种模式

RWMutex读写锁

1、读写限制

2、写锁

3、读锁

atomic原语

1、原子操作与互斥锁区别

2、方法

3、atomic.Value

如何保证线程安全

1、同步机制：

确保多个线程在访问共享数据时不会发生冲突

2、锁

实现同步的一种重要工具，阻止其他线程同时访问。常用的锁包括互斥锁、读写锁等。

3、原子操作

原子操作是不可中断的操作，即在执行完毕之前不会被其他线程打断。对于多线程环境中的某些关键操作，如计数器的增加，使用原子操作可以确保线程安全。

4、避免race（竞态条件）

竞态条件是指两个或多个线程在访问共享数据时，由于它们的执行顺序不同而导致结果不确定的情况。通过仔细设计程序逻辑和使用同步机制，可以避免竞态条件的发生。

5、使用线程安全的类和数据结构

许多编程语言和库都提供了线程安全的类和数据结构，如Java中的java.util.concurrent包中的类。使用这些类可以简化线程安全的实现，减少出错的可能性。

6、线程间的交互

在设计多线程程序时，应仔细考虑线程间的交互方式。例如，可以通过消息传递、事件驱动等方式来协调线程间的操作，以确保线程安全

几种锁

1、常用的锁

  • 互斥锁
    • 同一时刻只 有一个线程可以访问（包含读写）资源
    • 问题： 加锁失败时，会用阻塞进入内核态，当再次加锁成功，一共会有两次线程切换的成本
  • 自旋锁：
    • 特殊的互斥锁，在加锁失败时不会使线程进入休眠，而是处于忙等待，让线程在循环中不断检查锁的状态
    • 适用：持锁时间短的场景，不会造成线程切换
  • 读写锁
    • 允许多个线程同时读，但只允许一个线程写
    • 适用：可以区分读和写的场景，能提高并发

2、乐观锁与悲观锁

  • 乐观锁：操作数据时认为别人不会修改数据，实现方式——
    • CAS（CompareAndSwap）：仅数据是期望值时才修改。问题：
    • 需要额外的自旋重试机制，写法复杂且占用资源
    • 只能操作某一个变量，不适用于多个变量
    • ABA问题：① 线程 1 读取内存中数据为 A ②线程2将该数据修改为B ③线程2将该数据修改为A ④线程1对数据进行CAS操作。但使用栈时，虽然栈顶元素没变，但栈已经改变
    • 版本号机制：在数据中加一个version字段，数据有修改时+1，更新数据时，版本号一致才进行操作
  • 悲观锁
    • 操作数据时认为别人会修改数据，需要加锁
    • 互斥锁、自旋锁、读写锁都是悲观锁

3、死锁

原因：多个线程争夺资源
满足条件：互斥条件、占用等待条件、不可抢占、循环等待
如何避免：
  • 合理的资源分配
  • 避免嵌套锁
  • 按序获取资源：给资源编号，线程按顺序请求资源，按相反顺序释放资源
  • 超时放弃
  • 定期检查死锁

Mutex互斥锁

1、Mutex结构

type Mutex struct {
        state int32
        sema  uint32
}

state的32位表示：

  • mutexLocked — 最低1位，表示互斥锁的锁定状态；
  • mutexWoken — 低2位，表示从正常模式被从唤醒；
  • mutexStarving — 低3位，当前的互斥锁进入饥饿状态；
  • waitersCount — 其他位，当前互斥锁上等待的 Goroutine 个数；
底层实现：
  • 自旋：当锁被其他goroutine持有时，当前goroutine会进行一段时间的自旋（忙等待），而不是立即进入睡眠状态。以减少线程切换的开销
  • 阻塞：如果自旋一段时间后锁仍然被占用，goroutine会进入休眠，等待锁被释放。当锁被释放时时唤醒
  • 原子操作：底层使用了原子操作CAS，尝试获取锁或更新锁的状态
  • 公平性与非公平性：Mutex是非公平的，这意味着等待时间最长的goroutine并不一定会优先获得锁，锁有正常模式和饥饿模式

2、自旋的goroutine

如果一个G在时间片内没有完成任务，就会进入自旋状态（此时G依然持有P），如果自旋一段时间后仍然没有获得锁，那么该G对应的M就会释放cpu，并将G加入P的等待队列。

自旋可以避免 goroutine 的频繁切换，提高cpu性能

3、锁的两种模式

（1）正常模式

P的等待队列中的G会按照先进先出（FIFO）的顺序等待被唤醒。当一个G被唤醒时，并不能直接获得锁，而是要自己去抢占一次，但此时可能有其他G刚刚进入自旋流程，尝试获得锁，还没有加入阻塞队列。此时刚被唤醒的G与正在自旋的G竞争时，自旋的G更有优势，因为它正在占有cpu且数量更多。导致有部分G被饿死。

正常模式切换为饥饿模式：

  • 某个G超过1ms没有获取到锁

（2）饥饿模式

在饥饿模式下，想要获得这个锁的所有G都不会自旋等待，而是直接进入阻塞队列排队。那么锁就会直接被队头G获取。

饥饿模式切换回正常模式（满足其中之一）：

  • 某个G获取到了锁且是队列中最后一个G，没有其他G等待了
  • 某个G的等待时间小于1ms

RWMutex读写锁

1、读写限制

不限制并发读，但不能并行执行 读写、写写

2、写锁

（1）加锁 Lock()
  • 先用mutex阻塞后续写操作
  • atomic控制读的数量，阻塞后续读操作
  • 如果有其他goroutine持有读锁，会休眠等待所有读锁释放
    先阻塞写锁的获取，再阻塞读锁的获取，可以保证读操作不会被连续的写操作饿死，
（2）释放锁 UnLock()
  • 释放读锁
  • 释放所有由于获取读锁而等待的goroutine
  • 释放写锁

3、读锁

（1）加锁 RLock()
    atomic将读的数量readerCount++
  • 如果readerCount<0——表明有其他goroutine持有写锁，会休眠等待写锁释放
  • 如果readerCount>=0——加锁成功
（2）释放锁 RUnLock()
    atomic将读的数量readerCount--
  • 如果readerCount>=0——解锁成功
  • 如果读readerCount<0——有其他goroutine持有写锁，会等待写锁释放

atomic原语

1、原子操作与互斥锁区别

目的：
  • atomic: 对某个变量的互斥操作，粒度小
  • mutex:  保护一段逻辑操作，粒度较大
底层实现：
  • atomic:  硬件实现，利用 CPU 的原子指令（例如 CAS ， Compare-And-Swap ）
  • mutex:  软件实现，依赖调度器 

2、方法

对  int32 、 int64 、 uint32 、 uint64 、 uintptr 类型的各个方法：
  • 增减操作（ AddXXType ）：对操作数的原子增减
  • 载入操作（ LoadXXType ）：读取到操作数前，没有其他 routine 对其进行更改操作
  • 存储操作（ StoreXXType ）：存储保证原子性（避免被其他线程读取到修改一半的数据）
  • 比较并交互操作（ CompareAndSwapXXType ）：保证交换的 CAS ，只有原有值没被更改时才会交换
  • 交换操作（SwapXXType）：直接交换，不关心原有值

3、atomic.Value

Value 相当于一个容器，可用来原子存储或加载任意类型的值
存储有类型要求：
  • 不能存储nil（会panic）
  • value中存储的第一个值，决定了其后续的值类型
  • 尝试存储不同的类型，会panic 
m := make(map[int]int)
var config atomic.Value

go func() {
    var i int
    for {
        m[i] = rand.Intn(100)
        i++

        config.Store(m)
        time.Sleep(1 * time.Millisecond * 500)
    }
}()

time.Sleep(time.Second * 2)
c := config.Load().(map[int]int)
t.Log(c)

喝醉的小喵
关注
专栏目录
Go 学习笔记（66）— Go 并发同步原语（sync.Mutex、sync.RWMutex、sync.Once）及并发模型（ping-pong 模式、fan-in 模式、fan-out 模式）
wohu1104的专栏
11-28 990
1. 竞态条件 一旦数据被多个线程共享，那么就很可能会产生争用和冲突的情况。这种情况也被称为竞态条件（race condition），这往往会破坏共享数据的一致性。 举个例子，同时有多个线程连续向同一个缓冲区写入数据块，如果没有一个机制去协调这些线程的写入操作的话，那么被写入的数据块就很可能会出现错乱。 比如，在线程 A 还没有写完一个数据块的时候，线程 B 就开始写入另外一个数据块了。 显然，这两个数据块中的数据会被混在一起，并且已经很难分清了。因此，在这种情况下，我们就需要采取一些措施来协调它们对缓冲区
Go 学习笔记（23）— 并发（02）[竞争，锁资源，原子函数sync/atomic、互斥锁sync.Mutex]
wohu1104的专栏
04-28 513
本文参考 《Go 语言实战》 1. 竞争状态简述 如果两个或者多个 goroutine 在没有互相同步的情况下，访问某个共享的资源，并试图同时读和写这个资源，就处于相互竞争的状态，这种情况被称作竞争状态（race candition）。 对一个共享资源的读和写操作必须是原子化的，换句话说，同一时刻只能有一个 goroutine 对共享资源进行读和写操作。 // 这个示例程序展示如何在程序里...
Go - atomic包使用及atomic.Value源码分析
TIANTIAN_ZZ的博客
02-19 427
1. Go中的原子操作 原子性：一个或多个操作在CPU的执行过程中不被中断的特性，称为原子性。这些操作对外表现成一个不可分割的整体，他们要么都执行，要么都不执行，外界不会看到他们只执行到一半的状态。 原子操作：进行过程中不能被中断的操作，原子操作由底层硬件支持，而锁则是由操作系统提供的API实现，若实现相同的功能，前者通常会更有效率 最小案例： package main import ( "s...
Mutex和RWMutex
憨憨
03-31 556
锁的实现原理（Mutex和RWMutex） sync.Mutex(互斥锁) 为什么需要锁 在高并发或多goroutine同时执行时，可能会写入同一块内存 var count int var mu sync.Mutex func func1(){ for i :=0;i < 1000; i++{ go func(){ count =count+1 }() } time.Sleep(time.Second) fmt
Go语言原子操作—atomic
最新发布
CodeJR
09-02 818
在日常开发中，不可避免的会碰到并发场景，在Go语言中处理同步的方法通常是使用锁，但如果是对单一的一个整数操作，这个时候使用锁可能会造成更大的性能开销，而且代码也失去了美观与优雅。这个时候我们可以使用Go语言自带的原子操作，原子操作在Go语言的sync/atomic标准库里面，原子操作是比其他同步技术更基础的一种技术，而且原子操作是无锁的，通常是直接通过CPU指令实现。如果去看其他同步技术的源码可以看到很多技术都是依赖于原子操作的。
GOLANG sync.Mutex和sync.RWMutex
技术成就梦想，梦想成就未来。If you try hard enough, it can be.
06-02 1839
Package sync type Mutex A Mutex is a mutual exclusion lock. Mutexes can be created as part of other structures; the zero value for a Mutex is an unlocked mutex. A Mutex must not be copied
golang 互斥锁和读写锁（Mutex和RWMutex）
Bel_Ami_n的博客
03-07 1848
虽然Golang提供channel来保证协程的通信，但是某些场景用锁来显示保证协程的安全更清晰易懂。 Golang中主要有两种锁，互斥锁Mutex和读写锁RWMutex，下面分别介绍一下使用方法，以及出现死锁的常见场景。 一、Mutex（互斥锁） Mutex是互斥锁的意思，也叫排他锁，同一时刻一段代码只能被一个线程运行，使用只需要关注方法Lock（加锁）和Unlock（解锁）即可。 在Lock()和Unlock()之间的代码段称为资源的临界区(critical section)，是线程安全的，任何一个时.
atomic锁和mutex
xiaoxiaoyu85的专栏
08-23 440
https://www.cnblogs.com/a-xu/p/9240957.html
golang中sync.RWMutex和sync.Mutex区别
热门推荐
chenbaoke的专栏
12-16 4万+
golang中sync包实现了两种锁Mutex （互斥锁）和RWMutex（读写锁），其中RWMutex是基于Mutex实现的，只读锁的实现使用类似引用计数器的功能． type Mutex     func (m *Mutex) Lock()    func (m *Mutex) Unlock()type RWMutex    func (rw *RWMutex) Lock()    fu
GOLANG读写锁sync.RWMutex 原理分析
qq_36830901的博客
04-25 934
golang 中用sync.RWMutex实现了读写锁的协程间同步。 主要的数据结构如下。w是互斥锁，readerCount记录正在读取操作的协程数量同时也实现读锁。互斥锁w和readerCount共同实现了写锁。readerWait用来读锁都释放后唤醒写锁的记录数。writerSem，readerSem分别是等待读完成和写完成的信号量。 type RWMutex struct { w Mutex // held if there are pending writers wr
Go 源码之读写锁 sync.RWMutex
五岁小孩的博客
04-02 563
Go 源码之读写锁 sync.RWMutex
linux下mutex与atomic性能比较
boyhailong的专栏
01-28 5089
一种是用boost::atomic；一种直接加锁；代码很简单： #include #include #include #include #include #include #include #include static int loop_num = 10000; boost::atomic a(0); static boost::mutex mtx_; static v
Go atomic
JunChow
03-30 334
原子操作是指执行过程中不能被终端的操作，即针对某个值的原子操作过程中CPU绝对不会再去进行其它操作。为实现严谨，原子操作由一个独立的CPU指令代表和完成，并由操作系统提供调用，因此在并发环境下才能保证原子操作的绝对安全。 原子操作是能够保证执行期间是连续且不会被中断的，临界区只能保证访问共享数据是按顺序访问，但并不能保证访问期间不会被切换上下文。 Golang提供的原子操作都是非入侵式的，由标准库...
Go Atomic
云满笔记
08-01 1152
为了实现这样的严谨性,原子操由CPU提供芯片级别的支持,所以绝对有效,即使在拥有多CPU核心,或者多CPU的计算机系统中,原子操作的保证也是不可撼动的。该操作简称CAS(CompareAndSwap),第一个参数的值应该是指向被操作值的指针值,该值的类型即为*int32,后两个参数的类型都是int32类型,它们的值应该分别代表被操作值的旧值和新值,函数在被调用之后会先判断参数addr指向的被操作值与参数old的值是否相等。因为这很容易造成安全漏洞。...
Go-Atomic应用
Zerore的博客
09-09 231
atomic 操作的对象是一个地址，你需要把可寻址的变量的地址作为参数传递给方法，而不是把变量的值传递给方法。 提供的方法有： Add func AddInt32(addr *int32, delta int32) (new int32) 给一个地址上的内容加上值，返回新的值 CAS func CompareAndSwapInt32(addr *int32, old, new int32)(swapped bool) 比较并替换某个地址上的值，返回成功或失败。 因此代码里常用循环，失败后再次操作 Swa
go atomic 原子操作
小知识折射大智慧
02-24 643
atomic 包使用介绍
mgo中的atomic.Value
weixin_30721077的博客
04-11 135
闲话 最近在刷MIT的分布式课程,线程和锁一定是最基本的元素啦. 由于GO本身提倡的Share memory by communicating; don't communicate by sharing memory.,所以在实现的时候试图不用sharing memory + lock而多用channel来实现,这时候就带来了一些小小的不方便,比如一个字符串s可以被多个goroutin...
Go并发之atomic
zhghost的专栏
06-07 3470
1. atomic介绍： sync/atomic包提供了原子操作的能力，直接有底层CPU硬件支持，因而一般要比基于操作系统API的锁方式效率高些；这些功能需要非常小心才能...
with transaction.atomic():
05-20
`with transaction.atomic():` is a Python context manager that ensures that a group of database operations are executed as a single transaction. It's commonly used in Django web applications to ensure ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值