golang 携程 加锁

在Golang中，携程（goroutine）是一种轻量级的多线程实现方式，可以让开发者更方便地进行并发编程。然而，由于携程的特性，可能会导致竞态条件（Race Condition）的出现，进而影响程序的正确性和性能。为了解决这个问题，我们可以使用加锁机制保护共享资源，下面将介绍如何在Golang中使用加锁。

1. 同步原语

Golang中提供了一些同步原语来帮助我们实现加锁操作。其中最常见的就是互斥锁（Mutex）和读写锁（RWMutex）。

互斥锁用于保护共享资源，同时只能有一个携程持有锁。可以通过调用Mutex类型的Lock()方法获得锁，Unlock()方法释放锁。

读写锁在互斥锁的基础上做了优化，允许多个携程同时读取共享资源，但在有携程进行写操作时会阻塞其他读、写操作。可以通过调用RWMutex类型的RLock()方法获取读锁，RUnlock()方法释放读锁；Lock()方法获取写锁，Unlock()方法释放写锁。

2. 互斥锁示例

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

var count int
var mutex sync.Mutex

func increment() {
    mutex.Lock()
    count++
    mutex.Unlock()
}

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(count)
}

在上述代码中，我们定义了一个全局变量count和一个互斥锁mutex。在increment函数中，我们首先调用mutex.Lock()获取锁，然后对count进行加一操作，最后调用mutex.Unlock()释放锁。

3. 读写锁示例

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

var data map[int]int
var rwMutex sync.RWMutex

func readData(key int) int {
    rwMutex.RLock()
    defer rwMutex.RUnlock()
    return data[key]
}

func writeData(key, value int) {
    rwMutex.Lock()
    defer rwMutex.Unlock()
    data[key] = value
}

func main() {
    data = make(map[int]int)
    
    go func() {
        for i := 0; i < 100; i++ {
            writeData(i, i*2)
            time.Sleep(time.Millisecond)
        }
    }()
    
    go func() {
        for i := 0; i < 100; i++ {
            fmt.Println(readData(i))
            time.Sleep(time.Millisecond)
        }
    }()
    
    time.Sleep(time.Second)
}

在上述代码中，我们定义了一个全局变量data和一个读写锁rwMutex。在readData函数中，我们先调用rwMutex.RLock()获取读锁，然后返回data中对应key的值，最后调用rwMutex.RUnlock()释放读锁。在writeData函数中，我们先调用rwMutex.Lock()获取写锁，然后将key和value保存到data中，最后调用rwMutex.Unlock()释放写锁。

通过这种方式，我们实现了并发安全的读写操作。多个读操作可以同时进行，而写操作会阻塞其他读、写操作。