golang计数器

Go是一种现代的、并发的编程语言，通常用于高性能、可伸缩的网络服务和分布式系统。在Go语言中，计数器是一种常见的工具，用于跟踪事件的数量。计数器可以在多个goroutine之间安全地进行操作，是实现并发应用程序中重要的组件。

基本概念

计数器是一个具有自增和自减操作的整型变量。在Go中，可以使用原子操作或互斥锁来确保并发访问计数器时的线程安全性。原子操作是一种无法被中断的操作，能够保证内存访问的原子性。互斥锁则是一种同步原语，能够防止多个goroutine同时访问共享资源。

原子操作实现计数器

Go语言的sync/atomic包提供了一系列原子操作函数，可以用于实现计数器。其中最常用的是AddInt64和LoadInt64函数。AddInt64函数可以原子地将给定的值加到指定的地址，而LoadInt64函数用于原子地读取一个地址上的值。

下面是一个简单的实现示例：

import "sync/atomic"

var counter int64

func Increment() {
    atomic.AddInt64(&counter, 1)
}

func GetCount() int64 {
    return atomic.LoadInt64(&counter)
}

在上述示例中，counter变量使用int64类型，在Increment函数中通过atomic.AddInt64进行原子自增操作，而在GetCount函数中通过atomic.LoadInt64进行原子读取操作。

互斥锁实现计数器

除了原子操作外，互斥锁也可以被用来实现计数器。互斥锁能够确保只有一个goroutine可以进入临界区，从而保证计数器的操作是互斥的。

下面是一个使用互斥锁实现计数器的示例：

import "sync"

var counter int64
var mutex sync.Mutex

func Increment() {
    mutex.Lock()
    counter++
    mutex.Unlock()
}

func GetCount() int64 {
    mutex.Lock()
    defer mutex.Unlock()
    return counter
}

在上面的实现中，Increment函数通过调用mutex.Lock()和mutex.Unlock()方法来确保计数操作的互斥性。在GetCount函数中，使用了defer关键字来保证互斥锁的解锁操作一定会被执行。

选择合适的实现方式

在选择原子操作或互斥锁来实现计数器时，需要根据具体的场景和需求来进行权衡。

如果计数器的操作比较简单，且并发访问频率较高，使用原子操作可能是更好的选择。原子操作一般比互斥锁的性能更高，因为它不需要进行加锁和解锁的操作。

然而，如果计数器需要进行更复杂的操作，比如计算累计值或其他复杂逻辑，那么使用互斥锁来实现可能更合适。互斥锁提供了更灵活的方式来保护共享资源，可以在临界区内进行任意复杂的计算。

另外，需要注意的是，尽量避免过多地使用计数器来进行同步。过多地使用计数器可能会引起竞争条件，从而导致并发访问的性能下降。

var wg sync.WaitGroup

func DoTask() {
    // 模拟任务执行时间
    time.Sleep(time.Second)
    
    // 任务完成，计数减一
    wg.Done()
}

func Main() {
    for i := 0; i < 10; i++ {
        // 任务开始，计数加一
        wg.Add(1)
        go DoTask()
    }
    
    // 等待所有任务完成
    wg.Wait()
    
    fmt.Println("All tasks completed")
}

var semaphore = make(chan struct{}, 10)

func ServeRequest() {
    // 获取信号量
    semaphore <- struct{}{}
    
    // 执行请求处理逻辑
    // ...
    
    // 释放信号量
    <-semaphore
}

func Main() {
    for i := 0; i < 100; i++ {
        go ServeRequest()
    }
    
    // 防止主函数退出
    select{}
}