Go语言中channel和互斥锁的应用场景

package main
 
import (
    "fmt"
    "sync"
    "sync/atomic"
    "time"
)
 
// 使用互斥锁实现计数器
type CounterL struct {
    count int
    lock  sync.Mutex
}
 
func (c *CounterL) Increment() {
    c.lock.Lock()
    defer c.lock.Unlock()
    c.count++
}
 
func (c *CounterL) Value() int {
    c.lock.Lock()
    defer c.lock.Unlock()
    return c.count
}
 
// 使用原子操作实现计数器
type CounterA struct {
    count int
}
 
func (c *CounterA) Increment() {
    atomic.AddInt32(&c.count, 1)
}
 
func (c *CounterA) Value() int32 {
    return atomic.LoadInt32(&c.count)
}
 
func main() {
    const goroutines = 10
    var wg sync.WaitGroup
    wg.Add(2)
 
    // 测试互斥锁
    start := time.Now()
    var cl CounterL
    for i := 0; i < goroutines; i++ {
        go func() {
            for count := 0; count < 100; count++ {
                cl.Increment()
            }
            wg.Done()
        }()
    }
    wg.Wait()
    elapsed := time.Since(start)
    fmt.Printf("Mutex counter after %d goroutines: %d operations took %s\n", goroutines, cl.Value(), elapsed)
 
    // 测试原子操作
    start = time.Now()
    var ca CounterA
    for i := 0; i < goroutines; i++ {
        go func() {
            for count := 0; count < 100; count++ {
                ca.Increment()
            }
            wg.Done()
        }()
    }
    wg.Wait()
    elapsed = time.Since(start)
    fmt.Printf("Atomic counter after %d goroutines: %d operations took %s\n", goroutines, ca.Value(), elapsed)
}

这段代码定义了两种计数器：一种使用互斥锁来保护共享资源，另一种使用原子操作来同步并发访问。然后在主函数中，分别对每种计数器进行了性能测试，通过启动多个goroutines来进行计数操作，并记录运行时间。这样可以清晰地展示互斥锁和原子操作的应用场景和性能差异。