**Course Title:** Mastering Go: From Basics to Advanced Development **Section Title:** Concurrency in Go: Goroutines and Channels **Topic:** Develop a concurrent application using goroutines and channels.(Lab topic) **Objective:** By the end of this lab topic, you will be able to develop a concurrent application in Go using goroutines and channels, and understand how to effectively use these concurrency primitives to solve real-world problems. **Developing a Concurrent Application:** In this lab, we will develop a simple concurrent application that demonstrates the use of goroutines and channels for communication between them. **Example Application:** Let's develop a simple application that simulates a restaurant where multiple waiters take orders from customers and the kitchen staff prepares the orders concurrently. **Code:** ```go package main import ( "fmt" "time" ) // Order represents a customer order type Order struct { ID int Food string Waiter string } // Kitchen prepares the orders func kitchen(ch chan Order) { for order := range ch { fmt.Printf("Kitchen received order: %d %s from %s\n", order.ID, order.Food, order.Waiter) time.Sleep(2 * time.Second) fmt.Printf("Kitchen prepared order: %d %s for %s\n", order.ID, order.Food, order.Waiter) } } // Waiter takes orders from customers func waiter(id int, ch chan Order) { for i := 0; i < 5; i++ { order := Order{ ID: id, Food: fmt.Sprintf("Food-%d", i), Waiter: fmt.Sprintf("Waiter-%d", id), } fmt.Printf("Waiter-%d taking order: %d %s\n", id, order.ID, order.Food) ch <- order } } func main() { ch := make(chan Order) go kitchen(ch) for i := 1; i <= 3; i++ { go waiter(i, ch) } time.Sleep(15 * time.Second) } ``` **Explanation:** 1. We define an `Order` struct to represent a customer order. 2. The `kitchen` function runs in a goroutine and receives orders from the `ch` channel. It simulates preparing each order by sleeping for 2 seconds and then prints a message indicating that the order is prepared. 3. The `waiter` function runs in a goroutine and takes orders from customers. It sends each order to the `ch` channel for the kitchen to prepare. 4. In `main`, we create a buffered channel `ch` to communicate between the kitchen and waiter goroutines. We then start the kitchen goroutine and three waiter goroutines. **Key Concepts:** * **Communication between goroutines**: We use channels to communicate between the kitchen and waiter goroutines. * **Buffered and unbuffered channels**: We use a buffered channel to enable the kitchen and waiter goroutines to operate concurrently without blocking each other. * **Synchronization**: The `time.Sleep` function is used to simulate delays in order preparation and taking orders, demonstrating synchronization between goroutines. **Best Practices:** * Use channels to communicate between goroutines for concurrent execution. * Use buffered channels when the sender and receiver operate at different rates, and unbuffered channels for synchronization. * Use `time.Sleep` to simulate delays and demonstrate synchronization between goroutines. **Additional Resources:** * The Go documentation has an excellent section on [concurrency](https://tour.golang.org/concurrency/1), including goroutines and channels. * The [Go by Example](https://gobyexample.com/) website provides a concise tutorial on Go fundamentals, including concurrency. **Exercise:** 1. Modify the restaurant application to have multiple kitchen staff preparing orders concurrently. 2. Use a buffered channel to enable the kitchen staff to handle a maximum of 5 orders at a time. 3. Implement a synchronization mechanism to ensure that orders are prepared in the correct order. Feel free to leave a comment or ask for help after reading this topic if you have any questions or need further clarification on developing concurrent applications in Go using goroutines and channels. **Next Topic:** Best practices for error handling in Go.