Goroutine implementation doubts

I need some help on understanding how to use goroutines in this problem. I will post only some snippets of code but if you want to take a deep look you can check it out here

Basically, I have a distributor function which receives a request slice being called many times, and each time the function is called it must distribute this request among other functions to actually resolve the request. And what I'm trying to create a channel and launch this function to resolve the request on a new goroutine, so the program can handle requests concurrently.

How the distribute function is called:

// Run trigger the system to start receiving requests
func Run() {

	// Since the programs starts here, let's make a channel to receive requests
	requestCh := make(chan []string)
	idCh := make(chan string)

	// If you want to play with us you need to register your Sender here
	go publisher.Sender(requestCh)
	go makeID(idCh)
	// Our request pool
	for request := range requestCh {

		// add ID
		request = append(request, <-idCh)

		// distribute
		distributor(request)
	}
    
	// PROBLEM
    for result := range resultCh {
	    fmt.Println(result)
	}
}

The distribute function itself:

// Distribute requests to respective channels.
// No waiting in line. Everybody gets its own goroutine!
func distributor(request []string) {

	switch request[0] {

	case "sum":
		arithCh := make(chan []string)
		go arithmetic.Exec(arithCh, resultCh)
		arithCh <- request
	case "sub":
		arithCh := make(chan []string)
		go arithmetic.Exec(arithCh, resultCh)
		arithCh <- request
	case "mult":
		arithCh := make(chan []string)
		go arithmetic.Exec(arithCh, resultCh)
		arithCh <- request
	case "div":
		arithCh := make(chan []string)
		go arithmetic.Exec(arithCh, resultCh)
		arithCh <- request
	case "fibonacci":
		fibCh := make(chan []string)
		go fibonacci.Exec(fibCh, resultCh)
		fibCh <- request
	case "reverse":
		revCh := make(chan []string)
		go reverse.Exec(revCh, resultCh)
		revCh <- request
	case "encode":
		encCh := make(chan []string)
		go encode.Exec(encCh, resultCh)
		encCh <- request
	}
}

And the fibonacci.Exec function to illustrate how I'm trying to calculate the Fibonacci given a request received on the fibCh and sending the result value through the resultCh.

func Exec(fibCh chan []string, result chan map[string]string) {

	fib := parse(<-fibCh)
	nthFibonacci(fib)

	result <- fib
}

So far, at the Run function when I range over the resultCh I get the results but also a deadlock. But why? Also, I imagine that I should use the waitGroup function to wait the goroutines to finish but I'm not sure of how implement that since I'm expecting receive a continuous stream of requests. I would appreciate some help on understanding what I'm doing wrong here and a way to solve it.

I'm not digging into the implementation details of your application, but basically as it sounds to me, you can use the workers pattern.

Using the workers pattern multiple goroutines can read from a single channel, distributing an amount of work between CPU cores, hence the workers name. In Go, this pattern is easy to implement - just start a number of goroutines with channel as parameter, and just send values to that channel - distributing and multiplexing will be done by Go runtime, automagically.

Here is a simple implementation of the workers pattern:

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(tasksCh <-chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    for {
        task, ok := <-tasksCh
        if !ok {
            return
        }
        d := time.Duration(task) * time.Millisecond
        time.Sleep(d)
        fmt.Println("processing task", task)
    }
}

func pool(wg *sync.WaitGroup, workers, tasks int) {
    tasksCh := make(chan int)

    for i := 0; i < workers; i++ {
        go worker(tasksCh, wg)
    }

    for i := 0; i < tasks; i++ {
        tasksCh <- i
    }

    close(tasksCh)
}

func main() {
    var wg sync.WaitGroup
    wg.Add(36)
    go pool(&wg, 36, 50)
    wg.Wait()
}

Another useful resource how you can use the WaitGroup to wait for all the goroutines to finish the execution before to continue (hence to not trap into deadlock) is this nice article:

http://nathanleclaire.com/blog/2014/02/15/how-to-wait-for-all-goroutines-to-finish-executing-before-continuing/

And a very basic implementation of it:

<kbd>Go playground</kbd>

If you do not want to change the implementation to use the worker pattern maybe would be a good idea to use another channel to signify the end of goroutine execution, because deadlock happens when there is no receiver to accept the sent message through unbuffered channel.

done := make(chan bool)
//.....
done <- true //Tell the main function everything is done.

So when you receive the message you mark the execution as completed by setting the channel value to true.