Go语言基础之13--线程安全及互斥锁和读写锁

最新推荐文章于 2022-04-20 18:23:32 发布
最新推荐文章于 2022-04-20 18:23:32 发布
阅读量93 收藏
点赞数
原文链接：http://www.cnblogs.com/forever521Lee/p/9444233.html
版权

一、线程安全介绍

1.1 现实例子

A. 多个goroutine同时操作一个资源，这个资源又叫临界区

B. 现实生活中的十字路口，通过红路灯实现线程安全

C. 火车上的厕所（进去之后先加锁，在上厕所，不加锁两个人都进去就出问题了，出来后在解锁，别人就可以使用了），通过互斥锁来实现线程安全

D、在程序中，同一个变量多个goroutine去修改的时候，肯定是不允许同时修改的，同时修改肯定会出问题，所以当一个goroutine在修改之前需要加锁，修改结束在解锁，这样别的goroutine就可以去修改了。

1.2 实际例子

x = x +1

A. 先从内存中取出x的值

B. CPU进行计算， x+1

C. 然后把x+1的结果存储在内存中

解释：

就是两个goroutine同时去操作x（共享资源），最后的结果x并不是2，由于线程安全的问题，导致最后的结果还是等于1；

详情也如下图所示：

下面来看一个实际例子：

test1和test2函数都是在自增到1000000（对同一个变量count进行修改）

1）当test1函数和test2函数跑在同一个线程时：

package main

import (
    "fmt"
)

var count int

func test1() {
    for i := 0; i < 1000000; i++ {
        count++
    }
}

func test2() {
    for i := 0; i < 1000000; i++ {
        count++
    }
}

func main() {
    test1()
    test2()
    fmt.Printf("count=%d\n", count)
}

 执行结果如下：

因为是串行执行，所以最终结果肯定是2000000

 

2）当test1函数和test2函数独自起goroutine运行时：

package main

import (
    "fmt"
    "time"
)

var count int

func test1() {
    for i := 0; i < 1000000; i++ {
        count++
    }
}

func test2() {
    for i := 0; i < 1000000; i++ {
        count++
    }
}

func main() {
    go test1()
    go test2()

    time.Sleep(time.Second)
    fmt.Printf("count=%d\n", count)
}

 执行结果如下：

解释：

可以看到当test1和test2同时运行对count（共享资源）进行修改时，就会出现冲突，最终结果也就不是2000000了

1.3 如何解决？

那么如何解决上述线程安全问题呢，就是我们接下来要学习的互斥锁。

第2章 互斥锁

2.1 互斥锁介绍

A. 同时有且只有一个线程进入临界区，其他的线程则在等待锁；

B. 当互斥锁释放之后，等待锁的线程才可以获取锁进入临界区；

C. 多个线程同时等待同一个锁，唤醒的策略是随机的；

2.2 互斥锁使用实例

package main

import (
    "fmt"
    "sync" //互斥锁需要使用这个包。

    "time"
)

var count int
var mutex sync.Mutex //定义一个锁的变量(互斥锁的关键字是Mutex，其是一个结构体，传参一定要传地址，否则就不对了)
func test1() {
    for i := 0; i < 1000000; i++ {
        mutex.Lock() //对共享变量操作之前先加锁
        count++
        mutex.Unlock() //对共享变量操作完毕在解锁，这样就保护了共享的资源
    }
}

func test2() {
    for i := 0; i < 1000000; i++ {
        mutex.Lock()
        count++
        mutex.Unlock()
    }
}

func main() {
    go test1()
    go test2()

    time.Sleep(time.Second)
    fmt.Printf("count=%d\n", count)
}

 执行结果如下：

解释：

加锁（互斥锁）之后其实是相当于串行（对共享变量进行操作时）执行了，就算是goroutine也不例外。

2.3 互斥锁高阶实例

1）未加互斥锁代码（有问题）

package main

import (
    "fmt"
    "sync"
)

var x = 0

func increment(wg *sync.WaitGroup) {
    x = x + 1
    wg.Done()
}
func main() {
    var w sync.WaitGroup
    for i := 0; i < 1000; i++ {
        w.Add(1)
        go increment(&w)
    }
    w.Wait()
    fmt.Println("final value of x", x)
}

 执行结果：

2）添加互斥锁代码

package main

import (
    "fmt"
    "sync"
)

var x = 0

func increment(wg *sync.WaitGroup, m *sync.Mutex) {
    m.Lock()
    x = x + 1
    m.Unlock()
    wg.Done()
}
func main() {
    var w sync.WaitGroup
    var m sync.Mutex
    for i := 0; i < 1000; i++ {
        w.Add(1)
        go increment(&w, &m)
    }
    w.Wait()
    fmt.Println("final value of x", x)
}

 执行结果：

三、读写锁

3.1 使用场景

A. 读多写少的场景；

B. 分为两种角色，读锁和写锁；

C. 当一个goroutine获取写锁之后，其他的goroutine获取写锁或读锁都会等待；

D. 当一个goroutine获取读锁之后，其他的goroutine获取写锁都会等待, 但其他

goroutine获取读锁时，都会继续获得锁.；

3.2 读写锁案例演示

package main

import (
    "sync"
    "time"
)

var rwlock sync.RWMutex //定义一个锁的变量(读写锁的关键字是RWMutex，其是一个结构体，传参一定要传地址，否则就不对了)
var wg sync.WaitGroup
var count int

func writer() { //写的线程
    for i := 0; i < 1000; i++ {
        // 加写锁
        rwlock.Lock() //加锁写锁之后，其他goroutine就不能针对该共享变量加读锁或写锁（读取或写入）了
        count++
        time.Sleep(10 * time.Millisecond) //模拟写操作需要10ms
        // 释放写锁
        rwlock.Unlock()
    }
    wg.Done()
}

func reader() { //读的线程
    for i := 0; i < 1000; i++ {
        // 加读锁
        rwlock.RLock() //对于读锁来说，其他goroutine依然可以对该共享变量进行读取（读锁）依然可以，但是写入不行，获取写锁需要等待。
        _ = count
        //fmt.Printf("count=%d\n", count)
        time.Sleep(1 * time.Millisecond) //模拟读操作场景需要1ms
        // 释放读锁
        rwlock.RUnlock()
    }
    wg.Done()
}

func main() {
    wg.Add(1)
    go writer()
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go reader() //读锁是并发的，这里加了for循环主要是为了模拟只要有1个goroutine能够读取到共享资源，其他的goroutine也可以获取到。
    }
    wg.Wait()
}

 执行结果：

3.3 读写锁和互斥锁性能比较

针对同一个程序，我们通过比较互斥锁和读写锁的耗时来进行直观展示：

首先计算读写锁性能：

代码示例如下：

package main

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

var rwlock sync.RWMutex //定义一个锁的变量(读写锁的关键字是RWMutex，其是一个结构体，传参一定要传地址，否则就不对了)
var wg sync.WaitGroup
var count int

func writer() { //写的线程
    for i := 0; i < 1000; i++ {
        // 加写锁
        rwlock.Lock() //加锁写锁之后，其他goroutine就不能针对该共享变量加读锁或写锁（读取或写入）了
        count++
        time.Sleep(10 * time.Millisecond) //模拟写操作需要10ms
        // 释放写锁
        rwlock.Unlock()
    }
    wg.Done()
}

func reader() { //读的线程
    for i := 0; i < 1000; i++ {
        // 加读锁
        rwlock.RLock() //对于读锁来说，其他goroutine依然可以对该共享变量进行读取（读锁）依然可以，但是写入不行，获取写锁需要等待。
        _ = count
        //fmt.Printf("count=%d\n", count)
        time.Sleep(1 * time.Millisecond) //模拟读操作场景需要1ms
        // 释放读锁
        rwlock.RUnlock()
    }
    wg.Done()
}

func main() {

    start := time.Now().UnixNano() //开始时间
    wg.Add(1)
    go writer()
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go reader() //读锁是并发的，这里加了for循环主要是为了模拟只要有1个goroutine能够读取到共享资源，其他的goroutine也可以获取到。
    }
    wg.Wait()
    end := time.Now().UnixNano() //结束时间
    cost := (end - start) / 1000 / 1000 / 1000
    fmt.Printf("cost %d s\n", cost)

}

 执行结果如下：

 

互斥锁性能：

见如下实例：

package main

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

var mlock sync.Mutex //声明互斥锁变量
var wg sync.WaitGroup
var count int

func writer_mutex() { //写的线程
    for i := 0; i < 1000; i++ {
        mlock.Lock()
        count++
        time.Sleep(10 * time.Millisecond) //模拟写操作需要10ms
        mlock.Unlock()
    }
    wg.Done()
}

func reader_mutex() { //读的线程
    for i := 0; i < 1000; i++ {
        mlock.Lock() //对于多个goroutine来说，互斥锁也是只有1个goroutine可以读，并不像读写锁一样，所有goroutine都可以读
        _ = count
        //fmt.Printf("count=%d\n", count)
        time.Sleep(1 * time.Millisecond) //模拟读操作场景需要1ms
        mlock.Unlock()
    }
    wg.Done()
}

func main() {

    start := time.Now().UnixNano() //开始时间
    wg.Add(1)
    go writer_mutex()
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go reader_mutex()
    }
    wg.Wait()
    end := time.Now().UnixNano() //结束时间
    cost := (end - start) / 1000 / 1000 / 1000
    fmt.Printf("cost %d s\n", cost)

}

 执行结果如下：

总结：

可以看到最终的结果是同一个程序互斥锁比读写锁耗时多了9秒，主要原因是在读的时候，读写锁可以多个读线程去读，而互斥锁依然只能是一个线程去读，1比10的比例，就造成了最终这个结果。

 

葵花宝典：

读多写少用读写锁，读写差不多用互斥锁。

转载于:https://www.cnblogs.com/forever521Lee/p/9444233.html

weixin_30692143
关注
Go 编程必备：bufio 库的全面指南与实战技巧
walkskyer的博客
01-04 2151
在这篇文章中，我们全面探索了 Go 语言的bufio库，包括它的主要组件和的使用方法和应用场景。bufio库作为 Go 标准库中的重要组成部分，其在提高数据处理效率和性能方面的作用不可忽视。
golang map 锁_go 安全map 实现, 互斥锁和读写锁
weixin_32284931的博客
12-23 814
###互斥锁其中Mutex为互斥锁，Lock()加锁，Unlock()解锁，使用Lock()加锁后，便不能再次对其进行加锁，直到利用Unlock()解锁对其解锁后，才能再次加锁．适用于读写不确定场景，即读写次数没有明显的区别，并且只允许只有一个读或者写的场景，所以该锁叶叫做全局锁．package mainimport ("fmt""sync""errors")type MyMap struct {...
Go语言锁的解读
weixin_34409357的博客
01-02 147
2019独角兽企业重金招聘Python工程师标准>>> ...
Go-一个线程读写锁例子
莫忘输赢的博客
04-21 275
1、Go语言中的读写锁 1、读写锁的定义 var rw sync.RWMutex 2.、读锁锁定与解锁 rw.RLock()//上锁 rw.RUnlock()//解锁 3、写锁的锁定或解锁 rw.Lock()//上锁 rw.Unlock()//解锁 4、互斥情况
go语言多线程学习笔记——互斥锁
weixin_43593012的博客
02-27 719
最近在学go语言的多线程，作为一门云时代的语言，并发处理应该是面试和应用中必不可少的一部分，强制自己写个笔记，好好整理一下，本人纯小白，只是课堂知识的自我消化，如果能帮助到大家，求之不得。 一、不加锁 多线程中使用睡眠函数不优雅，直接用sync.WaitGroup保证一个goroutine刚退出就可以继续执行，不需要自己猜需要sleep多久。 package main import ( "fmt" "sync" ) var wg sync.WaitGroup func main() { wg.Add(
初学go多线程互斥问题
black233的博客
08-09 191
@go学习错误记录 互斥学习 问题场景：多线程与全局变量 当多个线程同时调用一个函数，若该函中使用了全局变量，则应当小心，可能造成数据的被覆盖。 测试代码： package main import ( "fmt" "strconv" "time" ) type voice struct { } var strVoice string func printfVoice(str string) { strVoice = str time.Sleep(1 * time.Microsecond
Go-golang-set-Go的线程安全的和非线程安全的高性能集
08-14
这通常通过锁机制来实现，如互斥锁（mutex）或者读写锁（RWMutex）。非线程安全则意味着该数据结构在多线程环境下使用时，需要额外的同步措施来保证正确性。 在`golang-set`库中，线程安全的集通常使用sync包中的...
线程进程互斥锁
03-01
- **文件操作**：在多个线程或进程中，如果需要对同一个文件进行读写操作，使用互斥锁可以防止数据的混乱，确保每次只有一个线程或进程进行读写。 - **全局变量**：当多个线程需要修改全局变量时，互斥锁能确保...
Go语言实现互斥锁、随机数、time、List
09-20
在Go语言中，互斥锁（Mutex）是用于并发编程中的关键同步原语，它可以确保在多线程或goroutine环境下对共享资源的访问是互斥的，避免数据竞争问题。`sync.Mutex`是Go标准库`sync`包提供的一种互斥锁实现。 在给出的...
golang互斥锁和读写锁性能分析
myz123321的博客
04-05 1万+
在并发操作中为了防止多任务同时修改共享资源导致的不确定结果，我们可能会用到互斥锁和读写锁。 一：互斥锁 1.互斥锁有两种操作，获取锁和释放锁 2.当有一个goroutine获取了互斥锁后，任何goroutine都不可以获取互斥锁，只能等待这个goroutine将互斥锁释放 3.互斥锁适用于读写操作数量差不多的情况 二：读写锁 1.读写锁有四种操作 读上锁 读解锁 写上锁 写解锁 2.写锁最多有一...
[Golang]golang中自动锁的实现
vipally的专栏
11-09 1305
golang作为原生支持多线程的语言，为了实现线程安全的package，经常需要对全局变量自动加锁，以便安全的访问全局变量。 废话不多说，直接上代码： package main import (      "sync" "fmt" ) type AutoLock struct {     obj interface{}     lock sy
Go语言 读写锁&互斥锁原理剖析(1)
Carter的程序人生
04-25 939
读写锁首先我们看rwmutex.go里面定义了RWMutex结构体，RWMutex继承于Locker type Locker interface { Lock() Unlock() } type RWMutex struct { w Mutex // 互斥锁，写锁协程获取该锁后，其他写锁处于阻塞等待 writerSem uint32 // 写入等待信号量，...
Go语言并发与并行学习笔记(一)
热门推荐
kjfcpua的专栏
01-14 3万+
如果不是我对真正并行的线程的追求，就不会认识到Go有多么的迷人。 Go语言从语言层面上就支持了并发，这与其他语言大不一样，不像以前我们要用Thread库 来新建线程，还要用线程安全的队列库来共享数据。 以下是我入门的学习笔记。 首先，并行!=并发, 两者是不同的，可以参考:http://concur.rspace.googlecode.com/hg/talk/concur.htm
Go语言，锁
Cc
07-19 948
Sync 互斥量：sync.Mutex 读写锁：sync.RWmutex 条件变量：sync.cond 锁 锁的粒度越小越好 一个Goroutine访问在访问一个资源时，先将该资源锁住，防止其他Goroutine访问。访问完毕后解锁。其他Goroutine再来加锁访问。 //锁是自愿的。 // 锁锁定的是加锁和解锁内所有内容 互斥锁： 建议锁，不具有强制性。 保护公共数据。被锁住后，只有成功...
Go语言实现线程安全访问队列
海岛Blog
08-19 7998
这个例子用Go语言的包"container/list"实现一个线程安全访问的队列。其中不少细节耐人寻味，做出它则是花费了不少精力，找不到样例啊！ Go语言的许多优点自不必说，然而从C/C++程序角度看，语言的语法也好，程序的实现方式也好，看起来总有点怪怪的感觉。 在这个程序的基础上，是很容易实现一个线程安全访问的堆栈的。 Go语言程序： // structlist proj
go语言映射map的线程协程安全问题
03-25 9190
go语言映射map的线程协程安全问题
go 多线程
coolwriter的博客
06-29 1万+
goroutine Runtime包中提供了几个与goroutine相关的函数。Gosched()让当前正在执行的goroutine放弃CPU执行权限。调度器安排其他正在等待的线程运行。 请看以下例子： package main import ( "runtime" "fmt" ) func main(){ go sayHello() go sayWorl...
Go语言并发安全与锁
二哈
04-20 415
有时候在Go语言代码中可能会存在多个goroutine同时操作一个资源，这种情况会发生竞态问题（数据竞态）
go语言中的锁
w___kai的博客
02-15 1965
虽然提供了channel来保证协程中的通信,在某些情况下,还是更适合使用锁来保证线程的安全. go语言中的锁分两种:互斥锁mutex和读写锁rwmutex 1.互斥锁 mutex 互斥锁是线程安全中最常用的锁,基本原理就是对某个操作进行加锁,无论读写同一时间内只有一个协程可以对当前数据进行操作,只有对当前锁解锁后其他协程才可以继续进行操作,互斥锁不可以重入,对一个已经加过锁的数据再次加锁会引起恐慌...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值