Control flow — Pipeline — Fixed size channels

Fixed size (or buffered) channels in Go provide a way to store a limited number of values without requiring the sending goroutine to wait for the receiving goroutine to retrieve the data. This allows for some decoupling of goroutine operations, providing a buffer space that can help manage flow control in concurrent operations.

Scenario

Let's use a fixed size channel to create a pipeline where multiple producer goroutines send data to a consumer goroutine, and the channel acts as a buffer between them. This setup can help smooth out the rate differences between fast producers and a slower consumer.

Go Code Example

Here's a practical example demonstrating how to use a buffered channel in a Go program:

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

func main() {
	// Create a buffered channel of size 3
	dataChannel := make(chan int, 3)

	var wg sync.WaitGroup

	// Start three producer goroutines
	for i := 1; i <= 3; i++ {
		wg.Add(1)
		go producer(i, dataChannel, &wg)
	}

	// Start one consumer goroutine
	go consumer(dataChannel)

	// Wait for all producers to finish
	wg.Wait()
	close(dataChannel) // Close the channel after all producers are done
}

// producer generates numbers and sends them to the data channel
func producer(id int, data chan<- int, wg *sync.WaitGroup) {
	defer wg.Done()
	for j := 0; j < 5; j++ {
		number := rand.Intn(100) // Generate a random number
		fmt.Printf("Producer %d sending: %d\\\\n", id, number)
		data <- number // Send number to the channel
		time.Sleep(time.Duration(rand.Intn(1000)) * time.Millisecond) // Random delay
	}
}

// consumer receives numbers from the data channel and processes them
func consumer(data <-chan int) {
	for number := range data {
		fmt.Printf("Consumer received: %d\\\\n", number)
		time.Sleep(1 * time.Second) // Simulating a longer processing time
	}
}

Explanation

1. Buffered Channel Creation: A buffered channel dataChannel is created with a capacity of 3. This means it can hold up to three values before the sender has to wait.
2. Producers: The program starts three producer goroutines. Each producer sends 5 random numbers to the channel. The use of a buffered channel allows these producers to potentially queue up to three items in the channel without blocking, helping to manage flow when they produce faster than the consumer can consume.
3. Consumer: A single consumer goroutine reads from the channel. It simulates processing each received number, which takes longer than the producers take to send them, demonstrating the utility of the buffer.
4. WaitGroup and Synchronization: A sync.WaitGroup is used to wait for all producer goroutines to finish before closing the channel. This ensures that the consumer can continue to receive data until all producers are done without the risk of a panic from sending to a closed channel.
5. Output and Flow Control: The output shows the asynchronous nature of the producers and the consumer, where the consumer processes data at a steady pace while producers can quickly send a few numbers whenever the channel isn't full.

This example highlights how buffered channels can be useful in managing different production rates in concurrent Go applications, facilitating smoother interactions between goroutines. If you have any further questions or need more detailed examples, feel free to ask! 🔨🤖🔧

Control flow — Pipeline — Goroutines Cancellation

In Go, managing goroutines and handling their cancellation can be crucial, especially in long-running applications or when dealing with tasks that might need to be stopped before completion. Go doesn't have built-in support for killing a goroutine, but you can design your goroutines to listen for cancellation signals using channels. This design pattern is effective for controlling goroutine execution and cleanly shutting them down.

Scenario

Let's simulate a situation where we have multiple goroutines processing tasks, and we need to cancel these goroutines gracefully based on a specific condition, such as a timeout or user intervention.

Go Code Example

Here's how you can implement goroutine cancellation using channels: