Go语言线程安全之互斥锁与读写锁

目录
  • 一、互斥锁是什么?
    • 1.概念
    • 2.未加锁
    • 3.加锁之后
  • 二、读写锁【效率革命】
    • 1.为什么读写锁效率高
    • 2.使用方法
  • 三、sync.once
    • 1.sync.once产生背景
    • 2.sync.once机制概述
    • 3.sync.once注意点
    • 4.使用方法
  • 四、atomic原子包操作

前言:

单个线程时数据操作的只有一个线程,数据的修改也只有一个线程参与,数据相对来说是安全的,多线程时对数据操作的不止一个线程,所以同时对数据进行修改的时候难免紊乱

一、互斥锁是什么?

1.概念

互斥锁是为了并发的安全,在多个goroutine共同工作的时候,对于共享的数据十分不安全写入时容易因为竞争造成数据不必要的丢失。互斥锁一般加在共享数据修改的地方。

2.未加锁

  • 线程不安全,操作的全局变量会计算异常
package main

import (
    "fmt"
    "sync"
)

var x int = 0

var wg sync.WaitGroup

func add() {
    defer wg.Done()
    for i := 0; i < 5000; i++ {
        x++
    }
}
func main() {
    wg.Add(2)
    go add()
    go add()
    wg.Wait()
    fmt.Println(x)
}
/*
打印结果:(每次打印不一样,正常的结果应该是10000)
    6051
    5059
    5748
    10000
*/

3.加锁之后

  • 线程安全,全局变量计算无异常
package main

import (
    "fmt"
    "sync"
)

var x int = 0

var wg sync.WaitGroup

// 创建一个锁对象
var lock sync.Mutex

func add() {
    defer wg.Done()
    for i := 0; i < 5000; i++ {
        //加锁
        lock.Lock()
        x++
        //解锁
        lock.Unlock()
    }
}
func main() {
    wg.Add(2)
    //开启两个线程
    go add()
    go add()
    wg.Wait()
    fmt.Println(x)
}
/*
打印结果:
    全为10000
*/

二、读写锁【效率革命】

1.为什么读写锁效率高

使用锁的时候,安全与效率往往需要互相转换,对数据进行操作的时候,只会进行数据的读与写。 而读与读之间可以同时进行,读与写之间需要保证写的时候不去读。此时为了提高效率就发明读写锁,在读写锁机制下,安全没有丝毫降低,但效率进行了成倍的提升提升的效率在读与写操作次数差异越大时越明显

2.使用方法

代码如下(示例):

package main

import (
    "fmt"
    "sync"
    "time"
)

var (
    x      = 0
    rwlock sync.RWMutex
    wg     sync.WaitGroup
)

func write() {
    defer wg.Done()
    rwlock.Lock()
    x++
    rwlock.Unlock()
}

func read() {
    wg.Done()
    //开启读锁
    rwlock.RLock()
    fmt.Println(x)
    //释放读锁
    rwlock.RUnlock()
}
func main() {
    start := time.Now()
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go write()
    }
    // time.Sleep(time.Second)
    for i := 0; i < 10000; i++ {
        wg.Add(1)
        go read()
    }
    wg.Wait()
    fmt.Println(time.Now().Sub(start))
}

三、sync.once

1.sync.once产生背景

在多个goroutine中往往会由于线程不同步造成数据读写的冲突,特别是在进行文件打开对象创建的时候,可能会造成向关闭的文件写内容,使用未初始化的对象,或者对一个对象进行多次初始化。

2.sync.once机制概述

sync.once保证函数内的代码只执行一次, 实现的机制是在once内部有一个标志位,在执行代码的时候执行一次之后标志位将置为1后续判断标志位,如果标志位被改为1则无法再进行操纵

3.sync.once注意点

 sync.Once.Do()传进去的函数参数无参无返,一个once对象只能执行一次Do方法,向Do方法内传多个不同的函数时只能执行第一个传进去的,传进去Do方法的函数无参无返,可以用函数闭包把需要的变量传进去

4.使用方法

  • 一般结合并发使用,旨在对通道或文件只进行一次关闭
func f2(a <-chan int, b chan<- int) {
    for {
        x, ok := <-a
        if !ok {
            break
        }
        fmt.Println(x)
        b <- x * 10
    }
    // 确保b通道只关闭一次
    once.Do(func() {
        close(b)
    })
}

四、atomic原子包操作

原子包将指定的数据进行安全的加减交换操作; 网上还有一大堆关于原子包的api感兴趣的小伙伴可以自行百度,这里就不细细阐述了

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

var x int64 = 0

var wg sync.WaitGroup

/*
    原子操作是将数据进行打包枷锁,直接通过指定的函数进行相应的操作
    可以使用load读取、store写入、add修改、swap交换。
    // 类似于读取一个变量、对一个变量进行赋值
*/
func addone() {
    // 没有加锁进行并发的话,会产生数据丢失的情况
    defer wg.Done()
    // x++

    // 不用加锁也可以使用的行云流水
    // 第一个参数是进行操作的数据,第二个是增加的步长
    atomic.AddInt64(&x, 1)

}
func csf() {
    // 进行比较相等则将新值替换旧值
    ok := atomic.CompareAndSwapInt64(&x, 100, 200)
    fmt.Println(ok, x)
}

func main() {
    for i := 0; i < 50000; i++ {
        wg.Add(1)
        go addone()
    }
    wg.Wait()
    fmt.Println(x)
    x = 100
    csf()
    fmt.Println(123)
}

总结:
读写锁区分读者和写者,而互斥锁不区分 互斥锁同一时间只允许一个线程访问该对象,无论读写;读写锁同一时间内只允许一个写者, 但是允许多个读者同时读对象。 联系:读写锁在获取写锁的时候机制类似于互斥锁。

到此这篇关于Go语言线程安全之互斥锁与读写锁的文章就介绍到这了,更多相关Go语言互斥锁与读写锁内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Go 互斥锁和读写互斥锁的实现

    目录 互斥锁 读写互斥锁 先来看这样一段代码,所存在的问题: var wg sync.WaitGroup var x int64 func main() { wg.Add(2) go f() go f() wg.Wait() fmt.Println(x) // 输出:12135 } func f() { for i:=0;i<10000;i++ { x = x+1 } wg.Done() } 这里为什么输出是 12135(不同的机器结果不一样),而不是20000. 因为 x 的赋值,总共分为三个

  • Go语言原子操作及互斥锁的区别

    目录 增或减 比较并交换(Compare And Swap) 载入与存储 交换 原子值 原子操作与互斥锁的区别 原子操作就是不可中断的操作,外界是看不到原子操作的中间状态,要么看到原子操作已经完成,要么看到原子操作已经结束.在某个值的原子操作执行的过程中,CPU绝对不会再去执行其他针对该值的操作,那么其他操作也是原子操作. Go语言中提供的原子操作都是非侵入式的,在标准库代码包sync/atomic中提供了相关的原子函数. 增或减 用于增或减的原子操作的函数名称都是以"Add"开头的,

  • Go语言并发编程之互斥锁Mutex和读写锁RWMutex

    目录 一.互斥锁Mutex 1.Mutex介绍 2.Mutex使用实例 二.读写锁RWMutex 1.RWMutex介绍 2.RWMutex使用实例 在并发编程中,多个Goroutine访问同一块内存资源时可能会出现竞态条件,我们需要在临界区中使用适当的同步操作来以避免竞态条件.Go 语言中提供了很多同步工具,本文将介绍互斥锁Mutex和读写锁RWMutex的使用方法. 一.互斥锁Mutex 1.Mutex介绍 Go 语言的同步工具主要由 sync 包提供,互斥锁 (Mutex) 与读写锁 (R

  • Golang并发操作中常见的读写锁详析

    互斥锁简单粗暴,谁拿到谁操作.今天给大家介绍一下读写锁,读写锁比互斥锁略微复杂一些,不过我相信我们今天能够把他拿下! golang读写锁,其特征在于 读锁:可以同时进行多个协程读操作,不允许写操作 写锁:只允许同时有一个协程进行写操作,不允许其他写操作和读操作 读写锁有两种模式.没错!一种是读模式,一种是写模式.当他为写模式的话,作用和互斥锁差不多,只允许有一个协程抢到这把锁,其他协程乖乖排队.但是读模式就不一样了,他允许你多个协程读,但是不能写.总结起来就是: 仅读模式: 多协程可读不可写 仅

  • Go语言中使用 buffered channel 实现线程安全的 pool

    概述 我们已经知道 Go 语言提供了 sync.Pool,但是做的不怎么好,所以有必要自己来实现一个 pool. 给我看代码: 复制代码 代码如下: type Pool struct {   pool chan *Client } // 创建一个新的 pool func NewPool(max int) *Pool {   return &Pool{     pool: make(chan *Client, max),   } } // 从 pool 里借一个 Client func (p *P

  • GO语言并发编程之互斥锁、读写锁详解

    在本节,我们对Go语言所提供的与锁有关的API进行说明.这包括了互斥锁和读写锁.我们在第6章描述过互斥锁,但却没有提到过读写锁.这两种锁对于传统的并发程序来说都是非常常用和重要的. 一.互斥锁 互斥锁是传统的并发程序对共享资源进行访问控制的主要手段.它由标准库代码包sync中的Mutex结构体类型代表.sync.Mutex类型(确切地说,是*sync.Mutex类型)只有两个公开方法--Lock和Unlock.顾名思义,前者被用于锁定当前的互斥量,而后者则被用来对当前的互斥量进行解锁. 类型sy

  • golang线程安全的map实现

    网上找的协程安全的map都是用互斥锁或者读写锁实现的,这里用单个协程来实现下,即所有的增删查改操作都集成到一个goroutine中,这样肯定不会出现多线程并发访问的问题. 基本思路是后台启动一个长期运行的goroutine,阻塞的接受自己channel中的请求req,req分为不同的请求,比如读key,写key等,然后在这个goroutine中进行各种操作. 例: Get方法向readSig(channel)中发送一条请求.请求是readReq的指针,当run方法接收到信号时,读取底层map,将

  • Go语言线程安全之互斥锁与读写锁

    目录 一.互斥锁是什么? 1.概念 2.未加锁 3.加锁之后 二.读写锁[效率革命] 1.为什么读写锁效率高 2.使用方法 三.sync.once 1.sync.once产生背景 2.sync.once机制概述 3.sync.once注意点 4.使用方法 四.atomic原子包操作 前言: 单个线程时数据操作的只有一个线程,数据的修改也只有一个线程参与,数据相对来说是安全的,多线程时对数据操作的不止一个线程,所以同时对数据进行修改的时候难免紊乱 一.互斥锁是什么? 1.概念 互斥锁是为了并发的安

  • PHP程序中的文件锁、互斥锁、读写锁使用技巧解析

    文件锁 全名叫 advisory file lock, 书中有提及. 这类锁比较常见,例如 mysql, php-fpm 启动之后都会有一个pid文件记录了进程id,这个文件就是文件锁. 这个锁可以防止重复运行一个进程,例如在使用crontab时,限定每一分钟执行一个任务,但这个进程运行时间可能超过一分钟,如果不用进程锁解决冲突的话两个进程一起执行就会有问题. 使用PID文件锁还有一个好处,方便进程向自己发停止或者重启信号.例如重启php-fpm的命令为 kill -USR2 `cat /usr

  • Java并发编程之重入锁与读写锁

    重入锁 重入锁,顾名思义,就是支持重进入的锁,它表示该锁能够支持一个线程对资源的重复加锁.重进入是指任意线程在获取到锁之后能够再次获取该锁而不会被锁阻塞,该特性的实现需要解决以下两个问题. 1.线程再次获取锁.锁需要去识别获取锁的线程是否为当前占据锁的线程,如果是,则再次成功获取. 2.锁的最终释放.线程重复n次获取了锁,随后在第n次释放该锁后,其他线程能够获取到该锁.锁的最终释放要求锁对于获取进行计数自增,计数表示当前锁被重复获取的次数,而锁被释放时,计数自减,当计数等于0时表示锁已经成功释放

  • Java 重入锁和读写锁的具体使用

    重入锁 重入锁 ReentrantLock,顾名思义,就是支持重进入的锁,它表示该锁能够支持一个线程对资源的重复加锁.除此之外,该锁还支持获取锁时的公平和非公平性选择 所谓不支持重进入,可以考虑如下场景:当一个线程调用 lock() 方法获取锁之后,如果再次调用 lock() 方法,则该线程将会被自己阻塞,原因是在调用 tryAcquire(int acquires) 方法时会返回 false,从而导致线程阻塞 synchronize 关键字隐式的支持重进入,比如一个 synchronize 修

  • Java多线程编程中线程锁与读写锁的使用示例

    线程锁Lock Lock  相当于 当前对象的 Synchronized import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /* * Lock lock = new ReentrantLock(); * lock.lock(); lock.unLock(); * 类似于 synchronized,但不能与synchronized 混用 */ public class L

  • Go语言的互斥锁的详细使用

    目录 前言 Go语言互斥锁设计实现 mutex介绍 Lock加锁 初始化状态 自旋 抢锁准备期望状态 通过CAS操作更新期望状态 解锁 非阻塞加锁 总结 前言 当提到并发编程.多线程编程时,都会在第一时间想到锁,锁是并发编程中的同步原语,他可以保证多线程在访问同一片内存时不会出现竞争来保证并发安全:在Go语言中更推崇由channel通过通信的方式实现共享内存,这个设计点与许多主流编程语言不一致,但是Go语言也在sync包中提供了互斥锁.读写锁,毕竟channel也不能满足所有场景,互斥锁.读写锁

  • 一文掌握Go语言并发编程必备的Mutex互斥锁

    目录 1. Mutex 互斥锁的基本概念 2. Mutex 互斥锁的基本用法 3. Mutex 互斥锁的底层实现 3.1 等待队列 3.2 锁状态 4. Mutex 互斥锁的注意事项 4.1 不要将 Mutex 作为函数或方法的参数传递 4.2 不要在获取 Mutex 的锁时阻塞太久 4.3 不要重复释放 Mutex 的锁 4.4 不要在锁内部执行阻塞或耗时操作 5. 总结 在并发编程中,我们需要处理多个线程同时对共享资源的访问问题.如果不加控制地同时访问共享资源,就会导致竞争条件(Race C

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

    目录 1.互斥锁Mutex 1.1 Mutex介绍 1.2 Mutex使用实例 2.读写锁RWMutex 2.1 RWMutex介绍 2.2 RWMutex使用实例 1.互斥锁Mutex 1.1 Mutex介绍 Go 语言的同步工具主要由 sync 包提供,互斥锁 (Mutex) 与读写锁 (RWMutex) 就是sync 包中的方法. 互斥锁可以用来保护一个临界区,保证同一时刻只有一个 goroutine 处于该临界区内.主要包括锁定(Lock方法)和解锁(Unlock方法)两个操作,首先对进

随机推荐