登录
首页 >  Golang >  Go问答

Golang 中 RLock() 和 Lock() 的异同点是什么?

来源:stackoverflow

时间:2024-03-06 10:24:30 474浏览 收藏

大家好,今天本人给大家带来文章《Golang 中 RLock() 和 Lock() 的异同点是什么?》,文中内容主要涉及到,如果你对Golang方面的知识点感兴趣,那就请各位朋友继续看下去吧~希望能真正帮到你们,谢谢!

问题内容

Golang 中的 RLock() 和 Lock() 有什么区别?当我们使用互斥锁时如何高效地使用它们?


解决方案


lock():通过获取锁,一次只能有一个 go 例程读/写。

rlock():通过获取锁,多个go例程可以同时读取(而不是写入)。

package main

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

func main() {

    a := 0

    lock := sync.rwmutex{}

    for i := 1; i < 10; i++ {
        go func(i int) {
            lock.lock()
            fmt.printf("lock: from go routine %d: a = %d\n",i, a)
            time.sleep(time.second)
            lock.unlock()
        }(i)
    }

    b := 0

    for i := 11; i < 20; i++ {
        go func(i int) {
            lock.rlock()
            fmt.printf("rlock: from go routine %d: b = %d\n",i, b)
            time.sleep(time.second)
            lock.runlock()
        }(i)
    }

    <-time.after(time.second*10)
}

1) 当一个 go-routine 已经获取了 rlock() 时,另一个 go-routine 是否可以获取 lock() 进行写入,还是必须等到 runlock() 发生?

  • 要获取 lock() 进行写入,必须等到 runlock()

2)当有人已经为map获取了lock()时会发生什么,其他go例程是否仍然可以获得rlock()

  • 如果某人 x 已经获取了 lock(),那么其他获取 rlock() 的 go-routine 必须等待 x 释放锁(unlock())

3)假设我们在这里处理map,是否有可能出现“map并发读/写”错误?

  • map 不是线程安全的。所以“map并发读/写”可能会导致错误。

请参阅以下示例以获取更多说明:

package main

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

func main() {
    lock := sync.RWMutex{}

    b := map[string]int{}
    b["0"] = 0

    go func(i int) {
        lock.RLock()
        fmt.Printf("RLock: from go routine %d: b = %d\n",i, b["0"])
        time.Sleep(time.Second*3)
        fmt.Printf("RLock: from go routine %d: lock released\n",i)
        lock.RUnlock()
    }(1)

    go func(i int) {
        lock.Lock()
        b["2"] = i
        fmt.Printf("Lock: from go routine %d: b = %d\n",i, b["2"])
        time.Sleep(time.Second*3)
        fmt.Printf("Lock: from go routine %d: lock released\n",i)
        lock.Unlock()
    }(2)

    <-time.After(time.Second*8)

    fmt.Println("*************************************8")

    go func(i int) {
        lock.Lock()
        b["3"] = i
        fmt.Printf("Lock: from go routine %d: b = %d\n",i, b["3"])
        time.Sleep(time.Second*3)
        fmt.Printf("Lock: from go routine %d: lock released\n",i)
        lock.Unlock()
    }(3)

    go func(i int) {
        lock.RLock()
        fmt.Printf("RLock: from go routine %d: b = %d\n",i, b["3"])
        time.Sleep(time.Second*3)
        fmt.Printf("RLock: from go routine %d: lock released\n",i)
        lock.RUnlock()
    }(4)

    <-time.After(time.Second*8)
}

rwmutex 是读取器/写入器互斥锁。该锁可以由任意数量的读取器或单个写入器持有。 rwmutex 的零值是未锁定的互斥体。

首次使用后,不得复制 rwmutex。

如果一个 goroutine 持有 rwmutex 进行读取,并且另一个 goroutine 可能调用 lock,则在释放初始读锁之前,任何 goroutine 都不应该期望能够获取读锁。特别是,这禁止递归读锁定。这是为了确保锁最终变得可用;阻塞的 lock 调用会阻止新的读取者获取锁。

互斥锁是一种互斥锁。互斥体的零值是未锁定的互斥体。

golang提供的channel是并发控制的最佳实践,所以我认为使用sync.lock的有效方式不是使用它,而是使用channel。

以上就是《Golang 中 RLock() 和 Lock() 的异同点是什么?》的详细内容,更多关于的资料请关注golang学习网公众号!

声明:本文转载于:stackoverflow 如有侵犯,请联系study_golang@163.com删除
相关阅读
更多>
最新阅读
更多>
课程推荐
更多>