event_manager.go

package main

import (
	"log"
	"math/rand"
	"sync"
	"time"
)

func init() {
	log.SetFlags(log.Flags() | log.Lmicroseconds)
}

func main() {
	ace := Object{name: "Ace"}
	bob := Object{name: "Bob"}
	rob := Object{name: "Rob"}

	updateEvent := &Evt{Name: "UpdateEvent"}

	em := NewEvtMgr()

	for _, o := range []Object{ace, bob, rob} {
		em.AddListenerForEvent(updateEvent, o)
	}

	// Randomly generate events
	go func() {
		for {
			pause := time.Duration(rand.Intn(500)) * time.Millisecond
			log.Printf("*** Sleeping for %s ***", pause)
			time.Sleep(pause)
			log.Printf("*** Sending update ***")
			updateEvent.Update()
			em.SendEvent(updateEvent)
			log.Printf("*** Done ***")
		}
	}()

	time.Sleep(2 * time.Second)
}

type Evt struct {
	sync.Mutex
	Name      string
	Timestamp time.Time
}

func (e *Evt) Update() {
	e.Lock()
	defer e.Unlock()
	e.Timestamp = time.Now()
}

type EventListener interface {
	OnEvent(*Evt)
}

type Object struct {
	name string
}

func (o Object) OnEvent(e *Evt) {
	log.Printf("%s got: %q [%v]", o.name, e.Name, time.Since(e.Timestamp))
}

type EvtMgr struct {
	sync.Mutex
	emap map[*Evt][]EventListener
}

var globalEvtMgr = EvtMgr{emap: make(map[*Evt][]EventListener)}

func NewEvtMgr() *EvtMgr {
	// Singleton
	return &globalEvtMgr
}

func (em *EvtMgr) AddListenerForEvent(e *Evt, el EventListener) {
	em.Lock()
	defer em.Unlock()
	if lsrs, ok := em.emap[e]; ok {
		em.emap[e] = append(lsrs, el)
	} else {
		em.emap[e] = append(make([]EventListener, 0, 1), el)
	}
}

func (em *EvtMgr) SendEvent(e *Evt) {
	em.Lock()
	defer em.Unlock()
	if lsrs, ok := em.emap[e]; ok {
		var wg sync.WaitGroup

		wg.Add(len(lsrs))
		for _, el := range lsrs {
			go func(el EventListener) {
				el.OnEvent(e)
				wg.Done()
			}(el)
		}
		wg.Wait()
	}
}

Live code - https://play.golang.org/p/2_navgLTSGI