Waiting on a sync.Cond with a timeout

Is it possible in some easy way to do the equivalent of Java's

wait(long timeMillis)

which waits on a monitor (mutex+cond, roughly) for a specified amount of time, and returns if it is not signalled?

I can't find anything in the docs or googling around on this, and although it's of course possible to play some games with making a WaitGroup and having a timer goroutine pop, that seems tedious/annoying/inefficient to just get this simple functionality (which is by the way directly supported by any underlying systems thread library I've ever encountered)

Edit: Yes we have all read http://www.golang-book.com/10/index.htm as well as https://blog.golang.org/pipelines - again, creating more threads is a "bad" (non-performant) solution to this, and channels are also not well suited to this. Imagine for a use case a typical concurrent server Join() method... (Please do not tell me to invert the control and use a Listener pattern instead. You don't always have the luxury to change the API you are working with...)

You can implement a condition variable that supports Broadcast only (no Signal), with a channel. Here is a quick Gist of it:
https://gist.github.com/zviadm/c234426882bfc8acba88f3503edaaa36#file-cond2-go

You can also just utilize this technique of replacing a channel and closing the old one within your code. The code in Gist is using unsafe.Pointer and atomic operations to allow calling 'Broadcast' without acquiring the main sync.Locker. However in your own code, more often than not, you should be Broadcasting from within the acquire lock anyways so you don't need to do any of the unsafe/atomic stuff.

While this method works, you might want to also checkout: https://godoc.org/golang.org/x/sync/semaphore. If you make a weighted semaphore with a limit of 1, that will also give you all the abilities you need and it will also be fair.

No. There is no easy way to do this and based on that thread they aren't going to add one. (though perhaps discussing it with them may get you somewhere)

But there's always a hard way. 2 options:

1. Roll your own Cond that has this capability. (see https://golang.org/src/sync/cond.go)
2. Use OS-level capabilities via a syscall. (maybe a futex?)

The challenge here - and the reason why it's not trivial - is that goroutines aren't threads. Go has it's own custom scheduler. Creating your own Cond will involve tinkering with parts of runtime that aren't really meant to be tinkered with. (but, like I said, it's possible)

Sorry if that's limiting. Most of go is pretty straightforward - you can often jump down into the lower layer without too much trouble. But the scheduler is not like that. It's magic.

The magic works for most things, and they added the stuff in sync to cover some known cases where it doesn't. If you feel like you found another, maybe you can convince them to add it. (but it's not just a matter of reproducing an API from another programming language, or exposing an underlying API)

I sketched out a couple of possible alternatives in my GopherCon talk this year (see https://drive.google.com/file/d/1nPdvhB0PutEJzdCq5ms6UI58dp50fcAN/view). The “Condition Variables” section starts at slide 37, but this particular pattern is covered in more detail in the backup slides (101-105).

As zviadm notes, one option (https://play.golang.org/p/tWVvXOs87HX) is to close a channel.

Another option (https://play.golang.org/p/uRwV_i0v13T) is to have each waiter allocate a 1-buffered channel, and have the broadcaster send a token into the buffer to broadcast.

If the event is a persistent condition, such as “the queue is empty”, a third option (https://play.golang.org/p/uvx8vFSQ2f0) is to use a 1-buffered channel and have each receiver refill the buffer as long as the condition persists.

https://gitlab.com/jonas.jasas/condchan makes it possible to timeout on wait. Please see an example:

package main

import (
	"fmt"
	"sync"
	"time"
	"gitlab.com/jonas.jasas/condchan"
)

func main() {
	cc := condchan.New(&sync.Mutex{})
	timeoutChan := time.After(time.Second)

	cc.L.Lock()
	// Passing func that gets channel c that signals when
	// Signal or Broadcast is called on CondChan
	cc.Select(func(c <-chan struct{}) { // Waiting with select
		select {
		case <-c: // Never ending wait
		case <-timeoutChan:
			fmt.Println("Hooray! Just escaped from eternal wait.")
		}
	})
	cc.L.Unlock()
}

I ran into the same issue and it turned out to be pretty easy to solve using a channel.

• A signal is a send on a channel
• A wait is simply waiting for a message on a channel.
• A wait with timeout is just a select on a timer and the message.
• A broadcast is a loop sending messages until there's no one left who listens.

As with any condition variable, it's required to hold the mutex when you wait and highly recommended to hold it when you're signaling.

I wrote a in implementation that follows the Cond protocol and adds a WaitOrTimeout. It returns true if successful, false if timed out.

Here's my code along with some test cases! DISCLAIMER: This seems to work fine but hasn't been thoroughly tested. Also, fairness is not guaranteed. Threads waiting are released in the order the scheduler sees fit and not necessarily first come/first serve.

https://play.golang.org/p/K1veAOGbWZ

package main
import (
"sync"
"time"
"fmt"
)
type TMOCond struct {
L    sync.Locker
ch      chan bool
}
func NewTMOCond(l sync.Locker) *TMOCond {
return &TMOCond{ ch: make(chan bool), L: l }
}
func (t *TMOCond) Wait() {
t.L.Unlock()
<-t.ch
t.L.Lock()
}
func (t *TMOCond) WaitOrTimeout(d time.Duration) bool {
tmo := time.NewTimer(d)
t.L.Unlock()
var r bool
select {
case <-tmo.C:
r = false
case <-t.ch:
r = true
}
if !tmo.Stop() {
select {
case <- tmo.C:
default:
}
}
t.L.Lock()
return r
}
func (t *TMOCond) Signal() {
t.signal()
}
func (t *TMOCond) Broadcast() {
for {
// Stop when we run out of waiters
//
if !t.signal() {
return
}
}
}
func (t *TMOCond) signal() bool {
select {
case t.ch <- true:
return true
default:
return false
}
}
// **** TEST CASES ****
func lockAndSignal(t *TMOCond) {
t.L.Lock()
t.Signal()
t.L.Unlock()
}
func waitAndPrint(t *TMOCond, i int) {
t.L.Lock()
fmt.Println("Goroutine", i, "waiting...")
ok := t.WaitOrTimeout(10 * time.Second)
t.L.Unlock()
fmt.Println("This is goroutine", i, "ok:", ok)
}
func main() {
var m sync.Mutex
t := NewTMOCond(&m)
// Simple wait
//
t.L.Lock()
go lockAndSignal(t)
t.Wait()
t.L.Unlock()
fmt.Println("Simple wait finished.")
// Wait that times out
//
t.L.Lock()
ok := t.WaitOrTimeout(100 * time.Millisecond)
t.L.Unlock()
fmt.Println("Timeout wait finished. Timeout:", !ok)
// Broadcast. All threads should finish.
//
for i := 0; i < 10; i++ {
go waitAndPrint(t, i)
}
time.Sleep(1 * time.Second) 
t.L.Lock()
fmt.Println("About to signal")
t.Broadcast()
t.L.Unlock()
time.Sleep(10 * time.Second)
}