Golang, proper way to restart a routine that panicked

I have the following sample code. I want to maintain 4 goroutines running at all times. They have the possibility of panicking. In the case of the panic, I have a recover where I restart the goroutine.

The way I implemented works but I am not sure whether its the correct and proper way to do this. Any thoughts

package main

import (
	"fmt"
	"time"
)

var gVar string
var pCount int

func pinger(c chan int) {
	for i := 0; ; i++ {
		fmt.Println("adding ", i)
		c <- i
	}
}

func printer(id int, c chan int) {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("HERE", id)
			fmt.Println(err)
			pCount++
			if pCount == 5 {
				panic("TOO MANY PANICS")
			} else {
				go printer(id, c)
			}
		}
	}()

	for {
		msg := <-c
		fmt.Println(id, "- ping", msg, gVar)
		if msg%5 == 0 {
			panic("PANIC")
		}

		time.Sleep(time.Second * 1)

	}
}

func main() {
	var c chan int = make(chan int, 2)
	gVar = "Preflight"
	pCount = 0

	go pinger(c)
	go printer(1, c)
	go printer(2, c)
	go printer(3, c)
	go printer(4, c)

	var input string
	fmt.Scanln(&input)
}

You can extract the recover logic in a function such as:

func recoverer(maxPanics, id int, f func()) {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("HERE", id)
			fmt.Println(err)
			if maxPanics == 0 {
				panic("TOO MANY PANICS")
			} else {
				go recoverer(maxPanics-1, id, f)
			}
		}
	}()
	f()
}

And then use it like:

go recoverer(5, 1, func() { printer(1, c) })

Like Zan Lynx's answer, I'd like to share another way to do it (although it's pretty much similar to OP's way.) I used an additional buffered channel ch. When a goroutine panics, the recovery function inside the goroutine send its identity i to ch. In for loop at the bottom of main(), it detects which goroutine's in panic and whether to restart by receiving values from ch.

Run in Go Playground

package main

import (
	"fmt"
	"time"
)

func main() {
	var pCount int
	ch := make(chan int, 5)

	f := func(i int) {
		defer func() {
			if err := recover(); err != nil {
				ch <- i
			}
		}()

		fmt.Printf("goroutine f(%v) started\n", i)
		time.Sleep(1000 * time.Millisecond)
		panic("goroutine in panic")
	}

	go f(1)
	go f(2)
	go f(3)
	go f(4)

	for {
		i := <-ch
		pCount++
		if pCount >= 5 {
			fmt.Println("Too many panics")
			break
		}
		fmt.Printf("Detected goroutine f(%v) panic, will restart\n", i)
		f(i)
	}
}

Oh, I am not saying that the following is more correct than your way. It is just another way to do it.

Create another function, call it printerRecover or something like it, and do your defer / recover in there. Then in printer just loop on calling printerRecover. Add in function return values to check if you need the goroutine to exit for some reason.

The way you implemented is correct. Just for me the approach to maintain exactly 4 routines running at all times looks not much go_way, either handling routine's ID, either spawning in defer which may leads unpredictable stack due to closure. I don't think you can efficiently balance resource this way. Why don't you like to simple spawn worker when it needed

func main() {
...
    go func(tasks chan int){ //multiplexer
        for {
            task = <-tasks  //when needed
            go printer(task) //just spawns handler
        }
    }(ch)
...
}

and let runtime do its job? This way things are done in stdlib listeners/servers and them known to be efficient enough. goroutines are very lightweight to spawn and runtime is quite smart to balance load. Sure you must to recover either way. It is my very personal opinion.