Creating a Synchronous Rate Limiter

I am emulating a request process where I have a synchronous rate limiter (in the form of a channel with cap == number of items to be limited on). The desired rate limit is 1 request per 1 second.

The issue I believe is that I am using a blocking for and not a goroutine, however my desired goal is to emulate this process synchronously.

I desire that I notify my channel that an operation is being performed (the print statement in my code example), and until that is complete and finished. I'd like to make sure that if the operation succeeded in < 1 second. I wait the difference until I send the next for iteration.

Perhaps a channel is overkill since I'm not using goroutines here and I should do some time measuring at the start of each iteration and after each response is received to time.Sleep() for the difference? Is there a better way?

package main

import (
	"fmt"
	"time"
)

type Data struct {
	Field1 string
	Ch     chan struct{}
}

func main() {
	data := &Data{
		Field1: "hello world",
		Ch:     make(chan struct{}, 1),
	}

	// fill up our data channel bucket
	for i := 0; i < cap(data.Ch); i++ {
		data.Ch <- struct{}{}
	}
	defer close(data.Ch)

	// create goroutine to attempt to do something every 1 second
	go func() {
		ticker := time.NewTicker(1 * time.Second)
		defer ticker.Stop()
		for range ticker.C {
			_, ok := <-data.Ch
			if !ok {
				return
			}
		}
	}()

	count := 0
	for {
		if count == 10 {
			fmt.Println("breaking the loop!")
			break
		}

		// place token into channel to signal we are performing an operation
		data.Ch <- struct{}{}

		// do things
		fmt.Printf("hello user! it is: %s o clock!\n", time.Now().UTC().Format("2006-01-02T15:04:05.000Z07:00"))

		// remove token in channel so we can do more operations
		<-data.Ch
		count++
	}
}

You seem to be doing this backwards. If you want a simple rate limiter using a channel, then have a goroutine that fills the channel at a given rate:

go func() {
        ticker := time.NewTicker(1 * time.Second)
        defer ticker.Stop()
        for range ticker.C {
            select {
             case data.Ch<-struct{}{}:
             default:
            }
        }
}()

Then, consume from the channel to rate limit:

for {
  <-data.Ch
  // Do stuff
}