解析golang中的并发安全和锁问题

1. 并发安全

package main
 
import (
    "fmt"
    "sync"
)
 
var (
    sum int
    wg sync.waitgroup
)
 
func test() {
    for i := 0; i < 5000000; i++ {
        sum += 1
    }
    wg.done()
}
 
func main() {
    // 并发和安全锁
    wg.add(2)
    go test()
    go test()
 
    wg.wait()
    fmt.println(sum)
 
}

　　上面的代码中我们开启了两个goroutine去累加变量x的值，这两个goroutine在访问和修改x变量的时候就会存在数据竞争，导致最后的结果与期待的不符。

2. 互斥锁

package main
 
import (
    "fmt"
    "sync"
)
 
var (
    sum int
    wg sync.waitgroup
    mu sync.mutex  // 定义一个互斥锁
)
 
func test() {
    for i := 0; i < 10000000; i++ {
        // 互斥锁它能够保证同时只能有一个goroutine去访问共享资源
        mu.lock()
        sum += 1
        mu.unlock()
    }
    wg.done()
}
 
func main() {
    fmt.println(mu)
    // 并发和安全锁
    wg.add(2)
    go test()
    go test()
 
    wg.wait()
    fmt.println(sum)
 
}

　　使用互斥锁能够保证同一时间有且只有一个goroutine进入临界区，其他的goroutine则在等待锁；当互斥锁释放后，等待的goroutine才可以获取锁进入临界区，多个goroutine同时等待一个锁时，唤醒的策略是随机的。

3. 读写互斥锁

互斥锁是完全互斥的，但是有很多实际的场景下是读多写少的，当我们并发的去读取一个资源不涉及资源修改的时候是没有必要加锁的，这种场景下使用读写锁是更好的一种选择。读写锁在go语言中使用sync包中的rwmutex类型。

读写锁分为两种：读锁和写锁。当一个goroutine获取读锁之后，其他的goroutine如果是获取读锁会继续获得锁，如果是获取写锁就会等待；当一个goroutine获取写锁之后，其他的goroutine无论是获取读锁还是写锁都会等待。

package main
 
import (
    "fmt"
    "sync"
    "time"
)
 
var (
    x int
    wg sync.waitgroup
    mu sync.mutex  // 定义一个互斥锁
    rw sync.rwmutex  // 定义一个读写锁，注意：只有读多写少的时候，读写锁才能发挥其优势
)
 
func write() {
    rw.lock()
    x += 1
    time.sleep(10 * time.millisecond)  // 假设写入时间耗费10毫秒
    rw.unlock()
    wg.done()
}
func read() {
    rw.rlock()
    time.sleep(time.millisecond)
    rw.runlock()
    wg.done()
}
 
func main() {
    start := time.now()
    for i := 0; i < 10; i++ {
        wg.add(1)
        go write()
    }  // 写耗时：160毫秒左右
 
    for i := 0; i < 1000; i++ {
        wg.add(1)
        go read()
    }  // 读耗时：15毫秒左右
 
    wg.wait()
    end := time.now()
    fmt.println("执行时间：", end.sub(start))
}

　　需要注意的是读写锁非常适合读多写少的场景，如果读和写的操作差别不大，读写锁的优势就发挥不出来。

到此这篇关于golang中的并发安全和锁的文章就介绍到这了,更多相关golang并发和锁内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！