使用互斥鎖（mutex）可確保在任意時刻只有一個goroutine能訪問共享資源，從而避免競態(tài)條件；在Go中通過sync.Mutex的Lock()和Unlock()方法實現(xiàn)加鎖與解鎖，必須成對使用且推薦用defer Unlock()確保釋放；例如多個goroutine並發(fā)遞增計數(shù)器時，需在操作共享變量前加鎖，操作完成後自動解鎖；應(yīng)使用mutex的場景包括多goroutine讀寫共享數(shù)據(jù)、構(gòu)建並發(fā)安全的數(shù)據(jù)結(jié)構(gòu)或避免通道開銷時；常見錯誤有忘記解鎖、未保護所有共享數(shù)據(jù)訪問路徑及復(fù)制含mutex的結(jié)構(gòu)體，可用go run -race檢測問題。

A mutex in Go is a synchronization primitive used to protect shared data from being accessed or modified by multiple goroutines at the same time, which could lead to race conditions.

The term mutex stands for mutual exclusion — meaning only one goroutine can access a shared resource at any given time. In Go, mutexes are part of the sync package and are represented by the sync.Mutex type.

How Does a Mutex Work?

A mutex has two main operations:

• Lock() — acquires the lock. If another goroutine already holds the lock, the calling goroutine blocks (waits) until the lock is released.
• Unlock() — releases the lock so another goroutine can acquire it.

It's crucial to always pair a Lock() with a corresponding Unlock() , typically using defer to ensure the unlock happens even if a panic occurs.

Example: Using a Mutex to Protect a Counter

 package main

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

var (
    counter = 0
    mutex = sync.Mutex{}
)

func increment(wg *sync.WaitGroup) {
    defer wg.Done()
    mutex.Lock()
    defer mutex.Unlock()
    counter  
    fmt.Println("Counter:", counter)
}

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 5; i {
        wg.Add(1)
        go increment(&wg)
    }

    time.Sleep(time.Second) // Give goroutines time to finish
    wg.Wait()
}

In this example:

• Multiple goroutines call increment() .
• The mutex.Lock() ensures only one goroutine can modify counter at a time.
• defer mutex.Unlock() guarantees the lock is released after the function exits.

When Should You Use a Mutex?

You should use a mutex when:

• Multiple goroutines need to read and write shared data.
• You want to avoid race conditions without using channels.
• You're building a concurrent-safe data structure (like a concurrent map).

? Tip : Go encourages communication via channels ( chan ), but mutexes are often simpler and more efficient for protecting small critical sections.

Common Mistakes

• Forgetting to unlock (always use defer mutex.Unlock() ).
• Locking but not covering all access points to shared data.
• Copying a struct that contains a mutex (this breaks the protection).

Go's go run -race flag can help detect race conditions during testing.

Basically, a mutex is a simple but powerful tool for safe concurrency in Go — just lock before accessing shared state, and unlock when done.

以上是GO中有什麼啞光？的詳細(xì)內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！