How to wait for threads with low latency in go?

I've been trying to create a simple event loop wrapper in Go. But I got stumped, how was I supposed to keep track of operations in the current thread?
I wanted CurrentTick to run a function, and even if the calling function quits, not start the next tick until all functions run by CurrentTick quit. I thought I might use a mutex to monitor the number of threads, but I realized if I kept checking that over and over it would throttle the CPU. If I used time.Sleep it would be latent. How would you solve the problem?

package eventloop

import (
	"reflect"
)

type eventLoop *struct{
	functions []reflect.Value
	addFunc chan<-/*3*/ reflect.Value
	mutex chan/*1*/ bool
	threads int
}

func NewEventLoop() eventLoop {
	var funcs chan reflect.Value
	loop := eventLoop{
		[]Reflect.Value{},
		funcs = make(chan reflect.Value, 3),
		make(chan bool, 1),
		0,
	}
	go func(){
		for {
			this.mutex <- 1
			if threads == 0 {
			}
		}
	}
}

func (this eventLoop) NextTick(f func()) {
	this.addFunc <- reflect.ValueOf(f)
}

func (this eventLoop) CurrentTick(f func()) {
	this.mutex <- 1
	threads += 1
	<-this.mutex
	go func() {
		f()
		this.mutex <- 1
		threads -= 1
		<-this.mutex
	}()
}

If I understand your intent, I think you're overcomplicating things. I'd do it like this:

package eventloop

type EventLoop struct {
	nextFunc chan func()
	curFunc chan func()
}

func NewEventLoop() *EventLoop {
	el := &EventLoop{
		// Adjust the capacities to taste
		make(chan func(), 3),
		make(chan func(), 3),
	}
	go eventLoop(el)
	return el
}

func (el *EventLoop) NextTick(f func()) {
	el.nextFunc <- f
}

func (el *EventLoop) CurrentTick(f func()) {
	el.curFunc <- f
}

func (el *EventLoop) Quit() {
	close(el.nextFunc)
}

func eventLoop(el *EventLoop) {
	for {
		f, ok := <-el.nextFunc
		if !ok {
			return
		}
		f()

		drain: for {
			select {
			case f := <-el.curFunc:
				f()
			default:
				break drain
			}
		}
	}
}

Depending on your use, you may need to add some synchronization to make sure all tasks in the loop finish before your program exits.

I figured it out myself, after a lot of problems and random issues including using 15 as length instead of capacity... Seems you just have a thread send a message after you decrement the counter. (the loop.tick part could be inlined, but I'm not worried about that)

package eventloop

type eventLoop struct{
	functions []func()
	addFunc chan/*3*/ func()
	mutex chan/*1*/ bool
	threads int
	waitChannel chan bool
	pauseState chan bool
}
func (this *eventLoop) NextTick (f func()) {
	this.addFunc <- f
}

func (this *eventLoop) tick () {
	this.mutex <- true
	for this.threads != 0 {
		<-this.mutex
		<-this.waitChannel
		this.mutex <- true
	}
	<-this.mutex
	L1: for {
		select {
			case f := <-this.addFunc:
				this.functions = append(this.functions,f)
			default: break L1
		}
	}
	if len(this.functions) != 0 {
		this.functions[0]()
		if len(this.functions) >= 2 {
			this.functions = this.functions[1:]
		} else {
			this.functions = []func(){}
		}
	}	else {
		(<-this.addFunc)()
	}
}
func (this *eventLoop) CurrentTick (f func()) {
	this.mutex <- true
	this.threads += 1
	<-this.mutex
	go func() {
		f()
		this.mutex <- true
		this.threads -= 1
		<-this.mutex
		this.waitChannel <- true
	}()
}
func NewEventLoop () *eventLoop {
	funcs := make(chan func(),3)
	loop := &eventLoop{
		make([]func(),0,15), /*functions*/
		funcs, /*addFunc*/
		make(chan bool, 1), /*mutex for threads*/
		0, /*Number of threads*/
		make(chan bool,0), /*The "wait" channel*/
		make(chan bool,1), 
	}
	go func(){
		for { loop.tick() }
	}()
	return loop
}

Note: this still has lots of other problems.