Go語言中什么是互斥鎖

這篇文章將為大家詳細(xì)講解有關(guān)Go語言中什么是互斥鎖，文章內(nèi)容質(zhì)量較高，因此小編分享給大家做個參考，希望大家閱讀完這篇文章后對相關(guān)知識有一定的了解。

1、互斥鎖Mutex

1.1 Mutex介紹

Go 語言的同步工具主要由 sync 包提供，互斥鎖 (Mutex) 與讀寫鎖 (RWMutex) 就是sync 包中的方法。

互斥鎖可以用來保護(hù)一個臨界區(qū)，保證同一時刻只有一個 goroutine 處于該臨界區(qū)內(nèi)。主要包括鎖定（Lock方法）和解鎖（Unlock方法）兩個操作，首先對進(jìn)入臨界區(qū)的goroutine進(jìn)行鎖定，離開時進(jìn)行解鎖。

使用互斥鎖 (Mutex)時要注意以下幾點(diǎn)：

• 不要重復(fù)鎖定互斥鎖，否則會阻塞，也可能會導(dǎo)致死鎖（deadlock）；

• 要對互斥鎖進(jìn)行解鎖，這也是為了避免重復(fù)鎖定；

• 不要對未鎖定或者已解鎖的互斥鎖解鎖；

• 不要在多個函數(shù)之間直接傳遞互斥鎖，sync.Mutex類型屬于值類型，將它傳給一個函數(shù)時，會產(chǎn)生一個副本，在函數(shù)中對鎖的操作不會影響原鎖
  

總之，一個互斥鎖只用來保護(hù)一個臨界區(qū)，加鎖后記得解鎖，對于每一個鎖定操作，都要有且只有一個對應(yīng)的解鎖操作，也就是加鎖和解鎖要成對出現(xiàn)，最保險的做法時使用defer語句解鎖。

1.2 Mutex使用實例

下面的代碼模擬取錢和存錢操作：

package main

import (
 "flag"
 "fmt"
 "sync"
)

var (
    mutex   sync.Mutex
    balance int
    protecting uint  // 是否加鎖
    sign = make(chan struct{}, 10) //通道，用于等待所有g(shù)oroutine
)

// 存錢
func deposit(value int) {
    defer func() {
        sign <- struct{}{}
    }()

    if protecting == 1 {
        mutex.Lock()
        defer mutex.Unlock()
    }

    fmt.Printf("余額: %d\n", balance)
    balance += value
    fmt.Printf("存 %d 后的余額: %d\n", value, balance)
    fmt.Println()

}

// 取錢
func withdraw(value int) {
    defer func() {
        sign <- struct{}{}
    }()
    
    if protecting == 1 {
        mutex.Lock()
        defer mutex.Unlock()
    }

    fmt.Printf("余額: %d\n", balance)
    balance -= value
    fmt.Printf("取 %d 后的余額: %d\n", value, balance)
    fmt.Println()

}

func main() {
    
    for i:=0; i < 5; i++ {
        go withdraw(500) // 取500
        go deposit(500)  // 存500
    }

    for i := 0; i < 10; i++ {
  <-sign
 }
    fmt.Printf("當(dāng)前余額: %d\n", balance)
}

func init() {
    balance = 1000 // 初始賬戶余額為1000
    flag.UintVar(&protecting, "protecting", 0, "是否加鎖，0表示不加鎖，1表示加鎖")
}

上面的代碼中，使用了通道來讓主 goroutine 等待其他 goroutine 運(yùn)行結(jié)束，每個子goroutine在運(yùn)行結(jié)束之前向通道發(fā)送一個元素，主 goroutine 在最后從這個通道接收元素，接收次數(shù)與子goroutine個數(shù)相同。接收完后就會退出主goroutine。

代碼使用協(xié)程實現(xiàn)多次（5次）對一個賬戶進(jìn)行存錢和取錢的操作，先來看不加鎖的情況

余額: 1000
存 500 后的余額: 1500

余額: 1000
取 500 后的余額: 1000

余額: 1000
存 500 后的余額: 1500

余額: 1000
取 500 后的余額: 1000

余額: 1000
存 500 后的余額: 1500

余額: 1000
取 500 后的余額: 1000

余額: 1000
取 500 后的余額: 500

余額: 1000
存 500 后的余額: 1000

余額: 1000
取 500 后的余額: 500

余額: 1000
存 500 后的余額: 1000

當(dāng)前余額: 1000

可以看到出現(xiàn)了混亂，比如第二次1000的余額取500后還是1000，這種對同一資源的競爭出現(xiàn)了競態(tài)條件(Race Condition)。

下面來看加鎖的執(zhí)行結(jié)果：

余額: 1000
取 500 后的余額: 500

余額: 500
存 500 后的余額: 1000

余額: 1000
取 500 后的余額: 500

余額: 500
存 500 后的余額: 1000

余額: 1000
取 500 后的余額: 500

余額: 500
存 500 后的余額: 1000

余額: 1000
存 500 后的余額: 1500

余額: 1500
取 500 后的余額: 1000

余額: 1000
取 500 后的余額: 500

余額: 500
存 500 后的余額: 1000

當(dāng)前余額: 1000
加鎖后就正常了。

下面介紹更細(xì)化的互斥鎖：讀/寫互斥鎖RWMutex。

2、讀寫鎖RWMutex

2.1 RWMutex介紹

讀/寫互斥鎖RWMutex包含了讀鎖和寫鎖，分別對共享資源的“讀操作”和“寫操作”進(jìn)行保護(hù)。sync.RWMutex類型中的Lock方法和Unlock方法分別用于對寫鎖進(jìn)行鎖定和解鎖，而它的RLock方法和RUnlock方法則分別用于對讀鎖進(jìn)行鎖定和解鎖。

有了互斥鎖Mutex，為什么還需要讀寫鎖呢？因為在很多并發(fā)操作中，并發(fā)讀取占比很大，寫操作相對較少，讀寫鎖可以并發(fā)讀取，這樣可以提供服務(wù)性能。讀寫鎖具有以下特征：

也就是說：

• 如果某個共享資源受到讀鎖和寫鎖保護(hù)時，其它goroutine不能進(jìn)行寫操作。換句話說就是讀寫操作和寫寫操作不能并行執(zhí)行，也就是讀寫互斥；

• 受讀鎖保護(hù)時，可以同時進(jìn)行多個讀操作。
  

在使用讀寫鎖時，還需要注意：

• 不要對未鎖定的讀寫鎖解鎖；

• 對讀鎖不能使用寫鎖解鎖

• 對寫鎖不能使用讀鎖解鎖

2.2 RWMutex使用實例

改寫前面的取錢和存錢操作，添加查詢余額的方法：

package main

import (
 "fmt"
 "sync"
)

// account 代表計數(shù)器。
type account struct {
 num uint         // 操作次數(shù)
 balance int   // 余額
 rwMu  *sync.RWMutex // 讀寫鎖
}

var sign = make(chan struct{}, 15) //通道，用于等待所有g(shù)oroutine

// 查看余額：使用讀鎖
func (c *account) check() {
 defer func() {
        sign <- struct{}{}
    }()
 c.rwMu.RLock()
 defer c.rwMu.RUnlock()
 fmt.Printf("%d 次操作后的余額: %d\n", c.num, c.balance)
}

// 存錢：寫鎖
func (c *account) deposit(value int) {
 defer func() {
        sign <- struct{}{}
    }()
    c.rwMu.Lock()
 defer c.rwMu.Unlock() 

 fmt.Printf("余額: %d\n", c.balance)   
 c.num += 1
    c.balance += value
    fmt.Printf("存 %d 后的余額: %d\n", value, c.balance)
    fmt.Println() 
}

// 取錢：寫鎖
func (c *account) withdraw(value int) {
    defer func() {
        sign <- struct{}{}
    }()
 c.rwMu.Lock()
 defer c.rwMu.Unlock()   
 fmt.Printf("余額: %d\n", c.balance)     
 c.num += 1
    c.balance -= value
 fmt.Printf("取 %d 后的余額: %d\n", value, c.balance)
    fmt.Println()  
}


func main() {
 c := account{0, 1000, new(sync.RWMutex)}

 for i:=0; i < 5; i++ {
        go c.withdraw(500) // 取500
        go c.deposit(500)  // 存500
  go c.check()
    }

    for i := 0; i < 15; i++ {
  <-sign
 }
 fmt.Printf("%d 次操作后的余額: %d\n", c.num, c.balance)

}

執(zhí)行結(jié)果：

余額: 1000
取 500 后的余額: 500

1 次操作后的余額: 500
1 次操作后的余額: 500
1 次操作后的余額: 500
1 次操作后的余額: 500
1 次操作后的余額: 500
余額: 500
存 500 后的余額: 1000

余額: 1000
取 500 后的余額: 500

余額: 500
存 500 后的余額: 1000

余額: 1000
存 500 后的余額: 1500

余額: 1500
取 500 后的余額: 1000

余額: 1000
取 500 后的余額: 500

余額: 500
存 500 后的余額: 1000

余額: 1000
取 500 后的余額: 500

余額: 500
存 500 后的余額: 1000

10 次操作后的余額: 1000

讀寫鎖和互斥鎖的不同之處在于讀寫鎖把對共享資源的讀操作和寫操作分開了，可以實現(xiàn)更復(fù)雜的訪問控制。

讀寫鎖也是一種互斥鎖，它是互斥鎖的擴(kuò)展。在使用時需要注意：

• 加鎖后一定要解鎖

• 不要重復(fù)加鎖或者解鎖

• 不解鎖未鎖定的鎖

• 不要傳遞互斥鎖
  

關(guān)于Go語言中什么是互斥鎖就分享到這里了，希望以上內(nèi)容可以對大家有一定的幫助，可以學(xué)到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。