simple go program to illustrate a central goroutine accepting requests and sending back responses to multiple waiting goroutines

coordinator.go

package main

import (
	"fmt"
	"sync"
	"time"

	"github.com/google/uuid"
)

type request struct {
	id uuid.UUID
	delay int
}

type response struct {
	id uuid.UUID
	value string
}

type central struct {
	listener chan request
	speakers map[uuid.UUID]*chan response
	sync.Mutex
}

func newCentral() *central {
	return &central{
		listener: make(chan request),
		speakers: make(map[uuid.UUID]*chan response),
	}
}

func (c *central) processor() {
	for r := range c.listener {
		fmt.Println("request recieved")
		time.Sleep(time.Second * time.Duration(r.delay))
		c.Lock()
		requiredCh := *(c.speakers[r.id])
		requiredCh <- response{
			id: r.id,
			value: fmt.Sprintf("I slept for %d seconds to stimulate an user interacting.", r.delay),
		}
		close(requiredCh)
		c.Unlock()
	}
	fmt.Println("processor finished working")
} 


func (c *central) worker() {
	genId := uuid.New()
	c.listener <- request{
		id: genId,
		delay: 1,
	}
	respCh := make(chan response)
	c.Lock()
	c.speakers[genId] = &respCh
	c.Unlock()
	fmt.Println("request sent")
	resp := <- respCh
	c.Lock()
	delete(c.speakers, genId)
	c.Unlock()
	fmt.Println("response recieved", resp)
}

func main()  {
	c := newCentral()
	var wg sync.WaitGroup

	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func () {
			c.worker()
			wg.Done()
		}()
	}

	go func ()  {
		c.processor()
	}()

	wg.Wait()
	close(c.listener)
}