计算在Go中调用（请求处理程序）函数的次数

Question

Context

I'm making a web app that serves dynamically generated pdfs. These contain content from the internet, so every time it serves a pdf, it downloads a number of files to a new temporary folder.

The Problem

I end up with a large number of folders after I load the page once, so it seems that, for some reason, the handler is being called multiple times, which is an issue because I'm downloading multiple times more than I need to of not insubstantial files. I'd like to check at what stage of the process multiple requests are occurring.

The Question

Is there a way of working out how many times a function has been called, quite possibly using closures? (I haven't quite got closures into my mental model for programming yet; I don't completely understand them/how they're used). This would preferably be something involving an int in the language rather than printing something at every stage and counting by hand - I'm looking for a more scalable solution than that (for later situations as well as this one).

Thanks!

Answer 1

Here are two ways you can count function calls, and one for method calls. There are plenty of other ways too, but just to get you started:

Using closure: (not what I would recommended)

package main

import(
    "fmt"
    "sync/atomic"
)

var Foo = func() (func() uint64) {
    var called uint64
    return func() uint64 {
        atomic.AddUint64(&called, 1)
        fmt.Println("Foo!")
        return called
    }
}()

func main() {
    Foo()
    c := Foo()
    fmt.Printf("Foo() is called %d times
", c)
}

Playground: http://play.golang.org/p/euKbamdI7h

Using global counter:

package main

import (
    "fmt"
    "sync/atomic"
)

var called uint64

func Foo() {
    atomic.AddUint64(&called, 1)
    fmt.Println("Foo!");
}

func main() {
    Foo()
    Foo()
    fmt.Printf("Foo() is called %d times
", called)
}

Playground: http://play.golang.org/p/3Ib29VCnoF

Counting method calls:

package main

import (
    "fmt"
    "sync/atomic"
)

type T struct {
    Called uint64
}

func (t *T) Foo() {
    atomic.AddUint64(&t.Called, 1)
    fmt.Println("Foo!")
}

func main() {
    var obj T
    obj.Foo()
    obj.Foo()
    fmt.Printf("obj.Foo() is called %d times
", obj.Called)
}

Playground: http://play.golang.org/p/59eOQdUQU1

Edit:

I just realized that the handler might not be in your own package. In such a case, you might want to write a wrapper:

var called uint64

func Foo() {
    atomic.AddUint64(&called, 1)
    importedPackage.Foo()
}

Edit 2:

Updated the examples to use atomic +1 operations.