Go语言中并发安全地统计函数与方法调用次数

package main

import (
    "fmt"
    "sync/atomic"
)

// Foo 是一个返回闭包的函数。这个闭包就是我们实际调用的函数。
var Foo = func() func() uint64 {
    var called uint64 // 闭包捕获的计数器变量
    return func() uint64 {
        atomic.AddUint64(&called, 1) // 原子地增加计数
        fmt.Println("Foo!")
        return called
    }
}() // 注意这里的括号，它会立即执行外层匿名函数，并将其返回的闭包赋值给 Foo

func main() {
    fmt.Printf("Initial call count: %d\n", Foo()) // 第一次调用，执行内部逻辑并返回计数
    fmt.Printf("Second call count: %d\n", Foo())  // 第二次调用

    c := Foo() // 第三次调用
    fmt.Printf("Foo() is called %d times\n", c)
}

package main

import (
    "fmt"
    "sync/atomic"
)

var globalCalled uint64 // 全局计数器

func Bar() {
    atomic.AddUint64(&globalCalled, 1) // 原子地增加全局计数
    fmt.Println("Bar!")
}

func main() {
    Bar()
    Bar()
    Bar()
    fmt.Printf("Bar() is called %d times\n", globalCalled)
}

package main

import (
    "fmt"
    "sync/atomic"
)

// Processor 结构体包含一个用于计数的字段
type Processor struct {
    Called uint64 // 方法调用计数器
}

// Process 方法用于处理一些逻辑，并增加调用计数
func (p *Processor) Process() {
    atomic.AddUint64(&p.Called, 1) // 原子地增加实例的计数
    fmt.Println("Processing...")
}

func main() {
    var myProcessor Processor // 创建一个 Processor 实例
    myProcessor.Process()     // 调用方法
    myProcessor.Process()     // 再次调用
    myProcessor.Process()     // 第三次调用
    fmt.Printf("myProcessor.Process() is called %d times\n", myProcessor.Called)

    anotherProcessor := &Processor{} // 另一个实例
    anotherProcessor.Process()
    fmt.Printf("anotherProcessor.Process() is called %d times\n", anotherProcessor.Called)
}

package main

import (
    "fmt"
    "sync/atomic"
    "time" // 假设这是一个外部包，其中有一个函数我们想计数
)

// 模拟外部包函数，我们无法直接修改其代码
func externalPackageFunc() {
    fmt.Println("Calling external package function...")
    time.Sleep(10 * time.Millisecond) // 模拟一些工作
}

var externalFuncCalled uint64 // 外部函数调用计数器

// WrappedExternalFunc 是 externalPackageFunc 的包装器
func WrappedExternalFunc() {
    atomic.AddUint64(&externalFuncCalled, 1) // 增加计数
    externalPackageFunc()                   // 调用原始外部函数
}

func main() {
    WrappedExternalFunc()
    WrappedExternalFunc()
    fmt.Printf("externalPackageFunc() (via wrapper) is called %d times\n", externalFuncCalled)
}