面试题：Go接口链式调用与并发安全

设计思路

互斥锁（Mutex）：使用sync.Mutex来保护共享数据。在对共享数据进行读写操作前，先获取锁，操作完成后释放锁。这样可以避免多个并发的链式调用同时修改共享数据，从而保证数据一致性。
读写锁（RWMutex）：如果链式调用中读操作远多于写操作，可以使用sync.RWMutex。读操作时获取读锁，允许多个读操作同时进行；写操作时获取写锁，此时不允许其他读写操作。
原子操作（Atomic）：对于一些简单的数据类型，如整数，可以使用atomic包提供的原子操作，这些操作在硬件层面保证了操作的原子性，无需额外的锁机制，性能更高。
通道（Channel）：使用通道来传递数据，通过通道的特性来控制并发访问。例如，将链式调用的中间结果通过通道传递，只有接收到数据的协程才能继续处理，这样可以避免多个协程同时处理同一数据。

代码示例

使用互斥锁

package main

import (
    "fmt"
    "sync"
)

type Data struct {
    value int
    mu    sync.Mutex
}

func (d *Data) SetValue(newValue int) *Data {
    d.mu.Lock()
    defer d.mu.Unlock()
    d.value = newValue
    return d
}

func (d *Data) GetValue() int {
    d.mu.Lock()
    defer d.mu.Unlock()
    return d.value
}

func main() {
    var wg sync.WaitGroup
    data := &Data{}

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            data.SetValue(id).GetValue()
        }(i)
    }

    wg.Wait()
    fmt.Println("Final value:", data.GetValue())
}

使用读写锁

package main

import (
    "fmt"
    "sync"
)

type Data struct {
    value int
    mu    sync.RWMutex
}

func (d *Data) SetValue(newValue int) *Data {
    d.mu.Lock()
    defer d.mu.Unlock()
    d.value = newValue
    return d
}

func (d *Data) GetValue() int {
    d.mu.RLock()
    defer d.mu.RUnlock()
    return d.value
}

func main() {
    var wg sync.WaitGroup
    data := &Data{}

    for i := 0; i < 10; i++ {
        if i%2 == 0 {
            wg.Add(1)
            go func(id int) {
                defer wg.Done()
                data.SetValue(id)
            }(i)
        } else {
            wg.Add(1)
            go func() {
                defer wg.Done()
                data.GetValue()
            }()
        }
    }

    wg.Wait()
    fmt.Println("Final value:", data.GetValue())
}

使用原子操作

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

type Data struct {
    value int64
}

func (d *Data) SetValue(newValue int64) *Data {
    atomic.StoreInt64(&d.value, newValue)
    return d
}

func (d *Data) GetValue() int64 {
    return atomic.LoadInt64(&d.value)
}

func main() {
    var wg sync.WaitGroup
    data := &Data{}

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            data.SetValue(int64(id)).GetValue()
        }(i)
    }

    wg.Wait()
    fmt.Println("Final value:", data.GetValue())
}

性能分析

互斥锁：使用简单，适用于读写操作频率相近的场景。但由于每次读写都需要获取锁，在高并发情况下可能成为性能瓶颈，因为锁的竞争会导致协程阻塞。
读写锁：在读多写少的场景下性能较好，因为读操作可以并发进行。但写操作时需要独占锁，会阻塞其他读写操作，所以如果写操作频率较高，性能会下降。
原子操作：性能最高，因为不需要锁，直接在硬件层面保证原子性。但仅适用于简单的数据类型，如整数、指针等，对于复杂数据结构无法使用。

在实际应用中，需要根据具体的业务场景和数据访问模式选择合适的方法来保证数据一致性和并发安全。

星途面试题库

面试题：Go接口链式调用与并发安全

知识考点

面试题答案

设计思路

代码示例

使用互斥锁

使用读写锁

使用原子操作

性能分析