Go并发与锁的两种方式该如何提效详解

先谈一下Go中的协程和锁

Go语言的协程是一种并发执行代码的方式。协程可以方便的并发执行任务，不需要等待前面的任务完成，直接执行下一个任务，提高了程序运行的效率。

而锁则可以保证在多个协程同时访问共享数据时不会发生冲突。

对于共享数据的并发访问，常用的两种方式

1. 互斥锁

互斥锁是最常用的一种锁。它可以保证在同一时刻只有一个协程可以访问共享资源。

Go语言中的Mutex是一种互斥锁。通过Mutex的Lock()和Unlock()方法可以实现对共享资源的互斥访问。

import (
    "sync"
)

var lock *sync.Mutex

func main() {
    lock = new(sync.Mutex)

    // 在协程中使用互斥锁对共享资源进行保护
    go func() {
        lock.Lock()
        defer lock.Unlock()

        // 访问共享资源
    }()
}

2. 读写锁

读写锁是一种更加灵活的锁，对于读写分离的场景，能够提供更好的性能。

读写锁分为两种：读锁和写锁。多个协程在同一时刻能够同时获取读锁，但只有一个协程能够获取写锁。

Go语言中的RWMutex是一种读写锁。通过RWMutex的RLock()和RUnlock()方法可以实现对共享资源的读取，通过Lock()和Unlock()方法可以实现对共享资源的写入。

import (
    "sync"
)

var lock *sync.RWMutex

func main() {
    lock = new(sync.RWMutex)

    // 在协程中使用读写锁对共享资源进行保护
    go func() {
        lock.RLock()
        defer lock.RUnlock()

        // 读取共享资源
    }()

    go func() {
        lock.Lock()
        defer lock.Unlock()

        // 写入共享资源
    }()
}

如何提高并发和锁的效率

1. 在不加锁的情况下尽可能的提高并发度

在不加锁的情况下，提高并发度能够显著提高程序的运行效率。但是过高的并发度可能会导致系统资源的过度占用，导致程序运行的效率反而降低。

var total int32

func doWork() {
    for {
        atomic.AddInt32(&total, 1)
    }
}

func main() {
    for i := 0; i < 100; i++ {
        go doWork()
    }
}

2. 选择合适的锁

在选择锁的时候，应该根据实际情况进行选择：

• 如果读操作比写操作更多，应该选择读写锁。
• 如果写操作比读操作更多，应该选择互斥锁。
• 如果对共享资源的访问非常频繁，应该选择轻量级的锁，例如sync包中的Atomic操作。

示例说明

示例一：互斥锁的使用

var count int32

func addCount() {
    lock.Lock()
    defer lock.Unlock()

    count++
}

func main() {
    lock = new(sync.Mutex)

    for i := 0; i < 1000; i++ {
        go addCount()
    }

    time.Sleep(1 * time.Second)
    fmt.Printf("count=%d", count)
}

以上示例中，多协程对count变量进行累加，但由于互斥锁的加入，最终count的值一定是1000。

示例二：读写锁的使用

var total int32

func addTotal() {
    lock.Lock()
    defer lock.Unlock()

    total++
}

func getTotal() int32 {
    lock.RLock()
    defer lock.RUnlock()

    return total
}

func main() {
    lock = new(sync.RWMutex)

    for i := 0; i < 1000; i++ {
        go addTotal()
    }

    time.Sleep(1 * time.Second)
    fmt.Printf("total=%d", getTotal())
}

以上示例中，多协程对total变量进行累加和获取，由于使用了读写锁，当多个协程对total进行读取时，仍然可以并发的执行，提高了程序的运行效率。