Concurrency Limiting with Semaphore, Why do I have to free up the buffer first?

Why will this code only work if <-sem; before results<-msg;? I thought <-sem frees up the buffer for a new subroutine. Apart from that is there a better way to return the result from a function within a go routine?

Logically I want to do this, but it doesnt work unless <-sem is above results<-msg.

var msg = printer(account)
results<-msg;
<-sem;

Here's my code:

package main

import (
	"fmt"
	"strconv"
	"time"
	//"runtime"
	"math/rand"
)

var intSlice = []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}

func printer(account int) string {
	 n := rand.Intn(1) 
    fmt.Printf("Sleeping %d seconds...\n", n)
    time.Sleep(time.Duration(n)*time.Second)
	return "Account Done " + strconv.Itoa(account) 
}

func main() {
    threads := 2
	
    results := make(chan string, threads)
   
    sem := make(chan bool, threads)

    for _, account := range intSlice {
        sem <- true //block
		
        go func(account int) {
			var msg = printer(account)
            defer func() { <-sem; results<-msg; }()
        }(account)
    }
	
    for i := 0; i < cap(sem); i++ {
        sem <- true
    }
	
    for i := 0; i < len(intSlice); i++ {
        select {
        case msg1 := <-results:
            fmt.Println("received", msg1)
        }
	}

}

so, the sem channel is initialized with a buffer of len=2

This allows for the program to push twice in this channel, before blocking in sem <- true //block.

To free a room from the channel, you read a value with <-sem once a job is done, which means that by now, someone else can push again to the channel and move on in sem <- true //block.

> Logically I want to do this, but it doesnt work unless <-sem is above
> results<-msg.
>
> var msg = printer(account)
> results<-msg;
> <-sem;

you can not write this because you are blocking at results<-msg. As results is not yet consumed by a reader, nothing allows for those instructions to move forward.

what happens really is that you are accumulating up to len(sem) routines on the stack blocking on up to len(results) at results <- msg in a separate routine.

They would unwind when you reach that loop for i := 0; i < len(intSlice); i++ {, but they don't because main blocks at sem <- true //block waiting for those on-stack routines to free room using <-sem.