golang锁详解

什么是golang锁

在并发编程中，锁是一种常用的同步机制。Golang提供了sync包来支持并发编程中的锁操作。锁用于保护共享资源，防止多个并发操作同时访问导致数据不一致或者竞态条件的发生。

golang锁的类型

Golang提供了两种主要的锁类型：互斥锁（Mutex）和读写锁（RWMutex）。

Golang互斥锁

互斥锁是最基本的锁类型，在同一时刻只允许一个goroutine访问共享资源。当一个goroutine获取到互斥锁时，其他goroutine需要等待直到该goroutine释放锁。

下面是互斥锁的使用示例：

package main

import (
	"fmt"
	"sync"
)

var (
	counter int
	mutex   sync.Mutex
)

func main() {
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go increment(&wg)
	}
	wg.Wait()
	fmt.Println("Final counter value:", counter)
}

func increment(wg *sync.WaitGroup) {
	mutex.Lock()
	counter++
	mutex.Unlock()
	wg.Done()
}

运行结果：

Final counter value: 10

Golang读写锁

读写锁是一种优化的锁类型，允许多个goroutine同时读取共享资源，但只允许一个goroutine写入共享资源。这样可以提高并发性能，适用于读多写少的场景。

下面是读写锁的使用示例：

package main

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

var (
	counter int
	rwLock  sync.RWMutex
)

func main() {
	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go read(&wg)
	}
	for i := 0; i < 2; i++ {
		wg.Add(1)
		go write(&wg)
	}
	wg.Wait()
	fmt.Println("Final counter value:", counter)
}

func read(wg *sync.WaitGroup) {
	rwLock.RLock()
	fmt.Println("Read value:", counter)
	time.Sleep(time.Millisecond)
	rwLock.RUnlock()
	wg.Done()
}

func write(wg *sync.WaitGroup) {
	rwLock.Lock()
	counter++
	fmt.Println("Write value:", counter)
	time.Sleep(time.Millisecond)
	rwLock.Unlock()
	wg.Done()
}

运行结果：

Read value: 0
Read value: 0
Read value: 0
Read value: 0
Read value: 0
Read value: 0
Read value: 0
Read value: 0
Read value: 0
Read value: 0
Write value: 1
Write value: 2
Final counter value: 2

Golang锁的性能比较

互斥锁和读写锁都是用于保护共享资源的锁类型，但在不同的并发场景下，它们的性能表现有所差异。

互斥锁适合于读写操作不频繁、读写时间相对较长的场景。由于互斥锁只允许一个goroutine访问共享资源，其他goroutine需要等待，因此适合于并发量较小的情况。

读写锁适合于读多写少的场景，可以提高并发性能。多个goroutine可以同时读取共享资源，不会相互阻塞，只有在写入时才会阻塞其他读写操作。

根据具体的使用场景和需求，选择合适的锁类型可以提高代码的并发性能。