建站
咨詢
售后
建站咨詢
新聞中心
這里有您想知道的互聯(lián)網(wǎng)營(yíng)銷解決方案
golang同步
Golang 中的同步原語(yǔ)有很多種，包括 Mutex、RWMutex、WaitGroup、Once 和 Cond 等。Mutex 是最常用的一種，它允許在共享資源上互斥訪問(不能同時(shí)訪問)。
同步原語(yǔ)是Golang中實(shí)現(xiàn)高效率并發(fā)編程的基礎(chǔ)，它們提供了一種在多個(gè)goroutine之間進(jìn)行通信和同步的方法，本文將詳細(xì)介紹Golang中的同步原語(yǔ)，包括互斥鎖、讀寫鎖、通道和原子操作等，以及如何使用這些同步原語(yǔ)來編寫高效的并發(fā)程序。
互斥鎖(Mutex)
互斥鎖是一種簡(jiǎn)單的同步原語(yǔ)，用于保護(hù)共享資源的訪問，當(dāng)一個(gè)goroutine獲得互斥鎖時(shí)，其他goroutine將被阻塞，直到鎖被釋放，互斥鎖的使用場(chǎng)景包括：保護(hù)共享數(shù)據(jù)結(jié)構(gòu)、限制同時(shí)訪問的goroutine數(shù)量等。
下面是一個(gè)使用互斥鎖的例子：
package main
import (
"fmt"
"sync/mutex"
"time"
)
var counter int
var mu sync.Mutex
func worker() {
for i := 0; i < 1000; i++ {
mu.Lock()
counter++
mu.Unlock()
time.Sleep(1 * time.Millisecond)
}
}
func main() {
go func() {
for i := 0; i < 1000; i++ {
mu.Lock()
counter++
mu.Unlock()
time.Sleep(1 * time.Millisecond)
}
}()
for i := 0; i < 2; i++ {
go worker()
}
time.Sleep(1 * time.Second)
fmt.Println("Counter:", counter)
}
讀寫鎖(Read-Write Lock)
讀寫鎖允許多個(gè)goroutine同時(shí)讀取共享資源，但只允許一個(gè)goroutine寫入，這使得讀操作比寫操作更高效，讀寫鎖的使用場(chǎng)景包括：讀多寫少的場(chǎng)景、緩存系統(tǒng)等。
下面是一個(gè)使用讀寫鎖的例子：
package main
import (
"fmt"
"sync/RWMutex"
"time"
)
var counter int64
var mtx = &RWMutex{}
var rwl = new(sync.RWMutex) // read lock is a wrapper of the write lock, so we can use it directly here.
var writers int64 // number of writers currently holding the lock. This is used to avoid deadlocks when no one is writing. If this value becomes zero and there are readers waiting, then the writer should release the lock and allow some of them to proceed. We do that by decrementing the counter and checking if it's zero. If so, we unlock and call the next reader or writer to acquire the lock. Otherwise, we just wait for someone else to release it. This way we ensure that no one is stuck waiting for the lock forever. The downside is that this approach introduces some overhead because we have to check whether there are any writers or not before allowing a reader to acquire the lock. However, this overhead is usually negligible compared to the benefit of having multiple readers working concurrently without blocking each other. The advantage of using a read lock is that you don't need to worry about deadlocks as much as with a write lock since you can always release your read lock and reacquire it later without affecting the other goroutines. Also, you can have multiple readers at the same time which makes sense in many cases where you want to serve multiple clients simultaneously but only one needs to update the data (the writer). In such cases, you can have several readers reading from the same data structure while only one writer updating it. This reduces contention and improves performance. When all readers finish their work they can release their read locks and let other readers start working on the data again. This allows you to achieve high concurrency without having to use a write lock. You can also use a write-read lock if you need both read and write operations on a single resource but still want to optimize for reads more than writes. In this case you would use a read lock for most of the time and a write lock only when you need to modify the data. This way you can reduce contention and improve performance for reads while still allowing concurrent writes if necessary.
分享文章：golang同步
轉(zhuǎn)載來源：http://www.dlmjj.cn/article/coodhge.html
