How can I overlap goroutines?

I have three gorutines, which should work in some sort of loop. For example, I have

go first() {
	// do some stuff
}
 
go second() {
	// do another kind of stuff
}

go third() {
	// do third kind of stuff
} 

And they have to work like that:
First - second - third - first - /and so on and so on/

I guess I have to use channels fo that, but I can't figure out proper way to do so.
If I make three different channels
FirstToSecond,
SeocndToThird,
ThirdToFirst, then when I run a program, I get error:

fatal error: all goroutines are asleep - deadlock!

But if I get rid of ThirdToFirst, I have one proper loop, and then gorutines start to work randomly.

I'm certainly missing something, but what?

Example code with two gorutines

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	wg.Add(2)

	ch1 := make(chan struct{})
	ch2 := make(chan struct{})

	go func() {
		for _, value := range []int{1, 3, 5} {
			<- ch1
			fmt.Println(value)
			ch2 <- struct{}{}	 
		} 
		wg.Done()
	}()

	go func() {
		for _, value := range []int{2, 4, 6} {
			<- ch2
			fmt.Println(value)
			ch1 <- struct{}{}
		} 
		wg.Done()
	}()

	wg.Wait()
}

If you need such sequencing, you might reevaluate your need to use goroutines. However, the way you described the solution is correct:

go first() {
  for {
    <-ch1
    // do stuff
    ch2<-struct{}{}
  } 
}()

go second() {
  for {
    <-ch2
    // do stuff
    ch3<-struct{}{}
  } 
}()

go third() {
  for {
    <-ch3
    // do stuff
    ch1<-struct{}{}
  } 
}()

However, this is a circular setup, and you have to start the first one outside this structure:

go first() {...}()
go second() {...}()
go third() {...} ()

// Start the first one
ch1<-struct{}{}