Go Heartbeat

External

• Concurrency in Go Katherine Cox-Buday, Chapter 5. "Concurrency at Scale" Section "Heartbeats"

Internal

• Go Concurrency

Overview

Heartbeats are a way for concurrent processes to signal life to outside parties.

There are two different types of heartbeats: that occur on a time interval, and that occur at the beginning of a unit of work.

Example

// makeHeartbeatChannel will start a goroutine that sends heartbeats with the given duration on the channel
// returned as result. The heartbeat will be canceled when the context is canceled. When the heartbeat is
// canceled, the returned channel will be closed.
func makeHeartbeatChannel(ctx context.Context, interval time.Duration) <-chan interface{} {
	c := make(chan interface{})
	ticker := time.NewTicker(interval)
	sendHeartbeat := func() {
		select {
		case c <- struct{}{}:
		default:
			// if the channel is blocked, give up, we'll send heartbeat next time
		}
	}
	go func() {
		defer close(c) // we own the channel, we must close it when it's not needed anymore
		defer ticker.Stop()
		for {
			select {
			case <-ctx.Done():
				fmt.Println("context canceled")
				return
			case <-ticker.C:
				sendHeartbeat()
			}
		}
	}()
	return c
}

...

ctx, cancel := context.WithCancel(context.Background())
heartbeat := makeHeartbeatChannel(ctx, 1*time.Second)
go func() {
	<-time.After(10 * time.Second)
	cancel()
}()
for {
	select {
	case _, ok := <-heartbeat:
		if ok == false {
			return
		}
		fmt.Println(".")
	}
}