Question

In object oriented languages I use class variables to track how many instances are currently spawned by incrementing on construction and decrementing on destruction.

I try to implement similar behaviour in go:

package entity

type Entity struct {
    Name string
}

func New(name string) Entity {
    entity := Entity{name}
    counter++
    return entity
}

var counter int = 0

func (e *Entity) Count() int {
    return counter
}

and that works half way as I can not decrement the counter via a destructor.

Can I somehow mimic object destruction?
How would I keep track of instance count correctly?

Answer 1

You can use runtime.SetFinalizer like this. See here for playground version.

package main

import (
    "fmt"
    "runtime"
)

type Entity struct {
    Name string
}

var counter int = 0

func New(name string) Entity {
    entity := Entity{name}
    counter++
    runtime.SetFinalizer(&entity, func(_ *Entity) {
        counter--
    })
    return entity
}

func (e *Entity) Count() int {
    return counter
}

func main() {
    e := New("Sausage")
    fmt.Println("Entities", counter, e)
    e = New("Potato")
    fmt.Println("Entities", counter, e)
    runtime.GC()
    fmt.Println("Entities", counter)
    e = New("Leek")
    fmt.Println("Entities", counter)
    runtime.GC()
    fmt.Println("Entities", counter)
}

This prints

Entities 1 {Sausage}
Entities 2 {Potato}
Entities 0
Entities 1
Entities 0

Note this from the docs for gotchas with Finalizers

The finalizer for x is scheduled to run at some arbitrary time after x
becomes unreachable. There is no guarantee that finalizers will run
before a program exits, so typically they are useful only for
releasing non-memory resources associated with an object during a
long-running program.