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来进行计数操作，并记录运行时间。这样可以清晰地展示互斥锁和原子操作的应用场景和性能差异。