golang加锁案例

在不同的并发编程中，加锁是一种常见的方法来保护共享资源。在golang中，通过使用内置的sync包，我们可以很容易地实现加锁操作。本文将介绍golang中的锁机制，包括使用互斥锁、读写锁和条件变量的不同场景。

互斥锁

互斥锁（Mutex）是最基本的一种锁机制。当我们需要在程序的某个部分引入同步，以保证共享资源的并发安全性时，就可以使用互斥锁。

互斥锁的基本用法如下：

``` package main import ( "fmt" "sync" ) var counter int var lock sync.Mutex func increment() { lock.Lock() defer lock.Unlock() counter++ } func main() { var wg sync.WaitGroup for i := 0; i < 1000; i++ { wg.Add(1) go func() { defer wg.Done() increment() }() } wg.Wait() fmt.Println(counter) } ```

在以上代码中，我们使用了互斥锁来确保counter变量的并发安全访问。使用lock.Lock()来获取锁，lock.Unlock()来释放锁。在increment()函数中，我们使用defer关键字来确保在函数返回前释放锁，这样可以避免忘记释放锁而导致的死锁问题。最后，我们使用sync.WaitGroup来等待所有goroutine完成任务。

读写锁

互斥锁适用于对共享资源的操作是非常短暂的情况，但如果共享资源的读操作远远多于写操作，使用互斥锁可能会导致性能问题。这时候，可以使用读写锁（RWMutex）。

读写锁有两种状态：读模式和写模式。在读模式下，多个goroutine可以同时读取共享资源，而在写模式下，只能有一个goroutine进行写操作。

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

``` package main import ( "fmt" "sync" "time" ) var counter int var rwLock sync.RWMutex func read() { rwLock.RLock() defer rwLock.RUnlock() fmt.Println("Read:", counter) } func write() { rwLock.Lock() defer rwLock.Unlock() counter++ fmt.Println("Write:", counter) } func main() { var wg sync.WaitGroup for i := 0; i < 10; i++ { go func() { defer wg.Done() read() }() } for i := 0; i < 2; i++ { wg.Add(1) go func() { defer wg.Done() write() }() } time.Sleep(time.Second) } ```

在以上代码中，我们使用了读写锁来保护counter变量的并发访问。多个goroutine可以同时读取counter，而写操作需要获取写锁。在read()函数中，我们使用了rwLock.RLock()来获取读锁，而在write()函数中，我们使用了rwLock.Lock()来获取写锁。通过使用读写锁，可以提高对共享资源的并发性能。

条件变量

除了互斥锁和读写锁，golang还提供了条件变量（Cond）来实现更高级的同步操作。条件变量允许goroutine在满足某些特定条件时进行等待和唤醒。

下面是一个使用条件变量的示例：

``` package main import ( "fmt" "sync" "time" ) var done bool var cond sync.Cond func producer() { time.Sleep(time.Second) cond.L.Lock() done = true cond.L.Unlock() cond.Broadcast() } func consumer() { cond.L.Lock() for !done { cond.Wait() } cond.L.Unlock() fmt.Println("Consumed") } func main() { done = false cond.L = new(sync.Mutex) go producer() go consumer() time.Sleep(2 * time.Second) } ```

在以上代码中，我们使用了条件变量来实现生产者-消费者模型。在producer()函数中，当生产者发出信号时，我们设置done的值为true，并调用cond.Broadcast()来唤醒所有被阻塞的消费者。在consumer()函数中，如果done的值为false，消费者就会进入等待状态，直到被唤醒。

通过使用条件变量，我们可以实现更复杂的同步场景，满足特定的条件时才执行操作，避免了忙等的情况。

总之，golang提供了丰富的锁机制，包括互斥锁、读写锁和条件变量，可以满足不同的并发编程需求。开发者可以根据具体的场景选择适当的锁机制来保护共享资源。合理地应用锁可以提高程序的并发性能，保证共享资源的安全性。