sync.Mutex

**同步互斥锁（Sync.Mutex）**

在多线程环境中，共享资源的访问可能会导致竞争条件（race condition），从而引起程序的不正确行为或崩溃。为了解决这个问题，我们可以使用同步互斥锁（sync.Mutex）来保护共享资源。

**什么是同步互斥锁？**

同步互斥锁是一种基本的线程同步机制，它允许一个线程独占某个资源，而其他线程必须等待直到该资源被释放。使用同步互斥锁可以确保在同一时间内，只有一个线程能够访问共享资源。

**如何使用同步互斥锁？**

要使用同步互斥锁，我们需要创建一个Mutex对象，然后在需要保护的代码块中使用Lock()方法来获取锁，Unlock()方法来释放锁。例如：

gopackage mainimport (
"fmt"
"sync"
)

func main() {
	var mu sync.Mutex	var count int	go func() {
	mu.Lock()
	count++
	mu.Unlock()
}()

	go func() {
	mu.Lock()
	count++
	mu.Unlock()
}()

	fmt.Println(count) // 输出2}

在这个例子中，我们使用两个goroutine同时访问一个共享变量count。由于我们使用了Mutex对象来保护count的访问，保证了只有一个线程能够修改count。

**Lock()和Unlock()方法**

Lock()方法用于获取锁，而Unlock()方法用于释放锁。如果尝试获取已经被其他线程占用的锁，则Lock()方法会阻塞直到锁被释放。Unlock()方法不需要任何参数，直接释放锁。

gofunc (m *Mutex) Lock() {
// ...
}

func (m *Mutex) Unlock() {
// ...
}

**使用示例**

下面是一个更复杂的示例，展示了如何使用同步互斥锁来保护一个共享资源：

gopackage mainimport (
"fmt"
"sync"
)

type BankAccount struct {
	balance int	mu sync.Mutex}

func (a *BankAccount) Deposit(amount int) {
	a.mu.Lock()
	defer a.mu.Unlock()
	a.balance += amount}

func (a *BankAccount) Withdraw(amount int) {
	a.mu.Lock()
	defer a.mu.Unlock()
	if a.balance >= amount {
	a.balance -= amount} else {
	fmt.Println("Insufficient balance")
}
}

func main() {
	account := &BankAccount{balance:1000}

	go account.Deposit(500)
	go account.Withdraw(200)

	time.Sleep(time.Second) // 等待goroutine执行完成	fmt.Println(account.balance) // 输出1300}

在这个例子中，我们使用一个BankAccount结构体来模拟银行账户。我们使用Mutex对象来保护balance的访问，确保只有一个线程能够修改balance。

**总结**

同步互斥锁是Go语言提供的一种基本的线程同步机制，它允许一个线程独占某个资源，而其他线程必须等待直到该资源被释放。使用同步互斥锁可以确保在同一时间内，只有一个线程能够访问共享资源。