Can we restrict function calling once at a time from goroutine - go

Question

I have following situation
wg.Add(1)
go func(wg *sync.WaitGroup) {
defer wg.Done()
for {
select {
case <-tickerCR.C:
_ = ProcessCommands()
case <-ow.quitCR:
logger.Debug("Stopping ProcessCommands goroutine")
return
}
}
}(&wg)
Can I somehow make sure that if ProcessCommands is executing then ignore the next ticker event. Basically I want to avoid parallel execution of ProcessCommands

Answer 1

What you want is called mutual exclusion. It can be achieved by Mutex.
var m Mutex
func process() {
m.Lock()
defer m.Unlock()
ProcessCommands()
}

Answer 2

You could create a type that has two fields, a function and a mutex, and when called his, lets say, run method, it locks, defers the unlock and calls the stored function. Afterwards you just need to create instances of that type with the required functions. OOP to the rescue. Remember that functions can be stored in a struct the same way a string would.
import (
"sync"
)
type ProtectedCaller struct {
m sync.Mutex
f func()
}
func (caller *ProtectedCaller) Call() {
caller.m.Lock()
defer caller.m.Unlock()
caller.f()
}
func ProtectCall(f func()) ProtectedCaller {
return ProtectedCaller{f: f}
}
var processCommands = ProtectCall(ProcessCommands)

Answer 3

There's a semi-standard module x/sync/singleflight:
How to use:
import "golang.org/x/sync/singleflight"
var requestGroup singleflight.Group
// This handler should call it's upstream only once:
http.HandleFunc("/singleflight", func(w http.ResponseWriter, r *http.Request) {
// define request group - each request can have it's specific ID
// singleflight ensures only 1 request with any given ID is processed at a time
// also you can have different IDs - to be processed simultaneously
// just set ID to "singleflight-1", "singleflight-2", etc
res, err, shared := requestGroup.Do("singleflight", func() (interface{}, error) {
fmt.Println("calling the endpoint")
response, err := http.Get("https://jsonplaceholder.typicode.com/photos")
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return nil, err
}
responseData, err := ioutil.ReadAll(response.Body)
if err != nil {
log.Fatal(err)
}
time.Sleep(2 * time.Second)
return string(responseData), err
})
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
result := res.(string)
fmt.Println("shared = ", shared)
fmt.Fprintf(w, "%q", result)
})
source

Answer 4

you can use sync.Once and prevent multiple calling a function, like this:
wg.Add(1)
var once sync.Once
go func(wg *sync.WaitGroup) {
defer wg.Done()
for {
select {
case <-tickerCR.C:
// look at this line, "ProcessCommands" function will call only once
once.Do(ProcessCommands)
case <-ow.quitCR:
logger.Debug("Stopping ProcessCommands goroutine")
return
}
}
}(&wg)