proposal: sync: sync.Once.Do return done

[eNV25]

Issue

It would be useful to know whether a function protected by sync.Once has been run or not.

Example:

var once sync.Once
var timer *time.Timer

func reset(d time.Duration) {
	done := false
	once.Do(func() {
		timer = time.AfterFunc(d, func() { ... })
		done = true
	})
	if !done {
		timer.Reset(d)
	}
}

Proposal

The above code relies on making new variable and setting it in the closure. It could be more cleanly expressed if sync.Once.Do return true or false depending on whether the function has run.

var once sync.Once
var timer *time.Timer

func reset(d time.Duration) {
	if !once.Do(func() {
		timer = time.AfterFunc(d, func() { ... })
	}) {
		timer.Reset(d)
	}
}

package sync
...
func (o *Once) Do(f func()) bool {
	if atomic.LoadUint32(&o.done) == 0 {
		o.doSlow(f)
		return true //
	}
	return false //
}
...

[thediveo]

just curious (and for clarification): since sync.Once.Do must be concurrency safe what would be your expectation of the returned value(s) when a second goroutine g2 calls sync.Once.Do while a first goroutine g1 was the first one ever and thus now executes the Do function? Should g2 get a return value of true too, or false? (it won't return until g1 has finished the Do(func) anyway.)

[seankhliao]

Duplicate of #41690

[eNV25]

@seankhliao that's not the same issue.

[eNV25]

False duplicate.

[seankhliao]

it's just a slightly different api
the reasoning for declining that one also applied here

[eNV25]

Issue #41690 is adding a new method. This is for adding a new return value for an existing method.

I have read the reason why that issues was closed and it doesn't apply. In this case running the function and getting the return value are the same action.

Please read @robpike's comment again.
#41690 (comment)

[ianlancetaylor]

I agree that this is slightly different, but we still aren't going to do it. The Go 1 compatibility guarantee does not permit us to add a result type to the Do method. We aren't going to add a new method for a very niche operation that can already be done in a more complicated way. Sorry.