高并发Go系统中Channel全局计数器去重及线程安全性问询

嘿，咱们来好好聊聊你的计数器问题～

第一个问题：原代码在高并发下会不会出现重复计数值？ #

先看你最初的代码：

package main 
import ( 
    "fmt" 
    "time" 
) 

var counter int 
var counter_chan chan int 

func main() { 
    counter_chan = make(chan int, 100) 
    counter = 0 
    go func() { 
        for { 
            select { 
            case chanc := <-counter_chan: 
                counter += chanc 
                fmt.Printf("%d \n", counter) 
            } 
        } 
    }() 

    for i := 0; i < 10; i++ { 
        go AddCounter(counter_chan) 
    } 
    time.Sleep(time.Second) 
    fmt.Printf("Total Count is ... %d \n", GetCount()) 
} 

func AddCounter(ch chan int) { 
    ch <- 1 
} 

func GetCount() int { 
    return counter 
} 

func ResetCount() { 
    if counter > 8190 { 
        counter = 0 
    } 
}

这里的核心问题不在计数累加环节——所有累加请求都由单个后台goroutine串行处理，channel的特性保证了这些操作不会并发执行，所以不会出现“多个goroutine分配到相同计数值”的情况（比如不会出现两个goroutine同时加1但只生效一次的问题）。

但隐患出在GetCount和ResetCount上：它们直接读写全局counter变量，完全没和后台goroutine做同步。想象一下，当后台goroutine正在执行counter += chanc时，刚好有goroutine调用GetCount，读到的可能是逻辑上不一致的中间值；更严重的是ResetCount，如果多个goroutine同时调用它，或者它和后台累加操作并行执行，就会触发竞态条件，导致计数器值混乱。

如果想用channel彻底解决问题，所有对计数器的操作（读、写、重置）都必须通过channel交给后台goroutine处理，不能直接读写全局变量。

第二个问题：修改后代码的线程安全性分析 #

再看你调整后的代码：

package main 
import ( 
    "fmt" 
    "time" 
) 

var counter int 
var addCounterChan chan int 
var readCounterChan chan int 

func main() { 
    addCounterChan = make(chan int, 100) 
    readCounterChan = make(chan int, 100) 
    counter = 0 
    go func() { 
        for { 
            select { 
            case val := <-addCounterChan: 
                counter += val 
                if counter > 5 { 
                    counter = 0 
                } 
                readCounterChan <- counter 
                fmt.Printf("%d \n", counter) 
            } 
        } 
    }() 

    for i := 0; i < 10; i++ { 
        go AddCounter(addCounterChan) 
    } 
    time.Sleep(time.Second) 
    for i := 0; i < 10; i++ { 
        fmt.Printf("Total Count #%d is ... %d \n", (i + 1), GetCount(readCounterChan)) 
    } 
} 

func AddCounter(ch chan int) { 
    ch <- 1 
} 

func GetCount(ch chan int) int { 
    r := <-ch 
    return r 
}

先给你吃个定心丸：修改后的代码里，计数器的累加和读取操作是线程安全的。原因如下：

1. 所有累加请求都通过addCounterChan交给后台单goroutine串行处理，完全消除了竞态；
2. 读取操作通过readCounterChan获取值，这个值是后台goroutine完成累加（及可能的重置）后主动发送的，保证读到的是最新且一致的计数器状态。

不过这里有个小瑕疵：当前逻辑是每处理一个累加请求，就往读通道发一次当前值。如果累加请求和读取请求的数量不匹配（比如累加10次但读15次），多余的读取请求会阻塞；反过来，如果读的次数比累加少，读通道会积压旧值，导致后续读取拿到过期数据。

另外，你把重置逻辑放在累加之后的操作是安全的，因为只有后台goroutine会修改counter，没有其他goroutine直接操作它。

更完善的Channel-based计数器实现 #

如果想让计数器支持任意的读、加、重置操作，更合理的方式是用一个专门的请求通道，把所有操作封装成请求发给后台goroutine，示例如下：

package main

import (
    "fmt"
    "time"
)

// 定义计数器操作的结构体
type counterOp struct {
    opType string // 操作类型："add", "get", "reset"
    delta  int    // 仅add操作需要，代表累加值
    resp   chan int // 仅get操作需要，用于返回结果
}

var counter int
var counterChan chan counterOp

func main() {
    counterChan = make(chan counterOp, 100)
    counter = 0

    // 后台处理所有计数器操作的goroutine
    go func() {
        for op := range counterChan {
            switch op.opType {
            case "add":
                counter += op.delta
                if counter > 8190 {
                    counter = 0
                }
            case "get":
                op.resp <- counter
            case "reset":
                counter = 0
            }
        }
    }()

    // 模拟并发累加操作
    for i := 0; i < 20; i++ {
        go func() {
            counterChan <- counterOp{opType: "add", delta: 1}
        }()
    }

    time.Sleep(time.Millisecond * 500)

    // 并发读取计数器值
    for i := 0; i < 5; i++ {
        go func(idx int) {
            respChan := make(chan int)
            counterChan <- counterOp{opType: "get", resp: respChan}
            fmt.Printf("Reader #%d got count: %d\n", idx, <-respChan)
        }(i)
    }

    // 重置计数器
    counterChan <- counterOp{opType: "reset"}

    time.Sleep(time.Millisecond * 500)
    finalResp := make(chan int)
    counterChan <- counterOp{opType: "get", resp: finalResp}
    fmt.Printf("Final count after reset: %d\n", <-finalResp)
}

这种实现的优势在于：

• 所有对计数器的操作都由单个goroutine串行处理，彻底消除竞态条件；
• 支持任意类型的操作（加、读、重置），扩展性更强；
• 读取操作通过专用响应通道获取值，保证每次读到的都是最新的一致状态。

内容的提问来源于stack exchange，提问作者simotunes