How to sync with pending results in channel?

I have a worker pool which offers a sync interface to pull out results:

func (p *Pool) Get() *Result {
    for {
        select {
        // if there are results in channel return them
        case r := <-p.results:
            return r
        // else check if there is any work pending we must wait for
        // if not return nil to indicate that all work was done
        default:
            if p.active < 1 {
                return nil
            }
        }
    }
}

The idea is that Get will return the next worker result or nil if all work is done.

The problem with this implementation now is that I need to manually keep track of all active work with the p.active counter. This feels somehow wrong as theoretically the information sits already in the length of the p.results channel.

What is an idiomatic approach to return nothing if a buffer is empty?

Sadly there's no len(chan), your approach is as good as it gets if you don't know the number of workers.

However you need some kind of synchronization for the counter, here's an extremely simple approach:

type Result struct {
	I int
}
type Pool struct {
	res chan *Result
	c   int32
}

func New() *Pool {
	return &Pool{
		res: make(chan *Result),
	}
}

func (p *Pool) Put(r *Result) {
	atomic.AddInt32(&p.c, 1)
	time.Sleep(time.Duration(100+r.I%1000) * time.Microsecond)
	p.res <- r
}

func (p *Pool) Get() (r *Result) {
	for {
		select {
		case r = <-p.res:
			atomic.AddInt32(&p.c, -1)
			return
		default:
			if atomic.LoadInt32(&p.c) == 0 {
				return
			}
		}
	}
}
func main() {
	runtime.GOMAXPROCS(8)
	p := New()
	for i := 0; i < 50; i++ {
		go p.Put(&Result{i})
	}
	time.Sleep(10 * time.Microsecond)
	for {
		r := p.Get()
		if r == nil {
			return
		}
		fmt.Println("r.I", r.I)
	}
}

//edit

For completeness sake, here's another example using WaitGroup, but again this is an overkill since internally WG uses atomic counters anyway.

type Pool struct {
	res chan *Result
	wg  sync.WaitGroup
}

func New(n int) (p *Pool) {
	p = &Pool{
		res: make(chan *Result, n),
	}
	p.wg.Add(n)
	go func() {
		p.wg.Wait()
		close(p.res)
	}()
	return
}

func (p *Pool) Get() *Result {
	for {
		r, ok := <-p.res
		if !ok {
			return nil
		}
		p.wg.Done()
		return r

	}
}

//func Put is the same as above and the test code is the same.

You could use a WaitGroup, and a gorouotine that blocks on it, and changes some flag when it's done.

So say you have a waitGroup, and for each item you enqueue you call wg.Add(1) on it. Every time you receive on the channel, or every time a worker finishes, it can call wg.Done() to decrease its counter.

Then you have a goroutine that waits for evertyhing to finish, and just sets a flag:

 go func() {
     wg.Wait()
     p.done = true //do this thread safe of course
 } 

And in your default case, you simply check the done flag

   default:
        if p.done {
            return nil
        }

See the docs on WaitGroup for more details. The example there is a bit similar to your case. http://golang.org/pkg/sync/#WaitGroup.Wait