简单探讨Go语言线程安全之互斥锁与读写锁

导读	这篇文章主要介绍了Go语言线程安全之互斥锁与读写锁,互斥锁是为了并发的安全,在多个goroutine共同工作的时候,对于共享的数据十分不安全,而读写锁效率革命，使用锁的时候，安全与效率往往需要互相转换，下文详细内容，需要的小伙伴可以参考一下

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

一、互斥锁是什么？

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)
}

总结：

读写锁区分读者和写者，而互斥锁不区分 互斥锁同一时间只允许一个线程访问该对象，无论读写；读写锁同一时间内只允许一个写者， 但是允许多个读者同时读对象。 联系：读写锁在获取写锁的时候机制类似于互斥锁。www.linuxprobe.com