Threading in Go

Description:

This Go code implements a producer-consumer model using goroutines and channels. The program simulates the concurrent production and consumption of items, demonstrating how multiple producers can generate items while multiple consumers process those items in a thread-safe manner.

Key Components

1. Item Struct:
   • Represents an item produced by the producers.
   • Each item has a unique identifier (id) assigned during initialization.
2. Producer Function:
   • The producer function generates items and sends them to a channel.
   • Each producer creates 5 items, each with a unique ID based on the producer's ID.
   • It simulates work by sleeping for a random duration after producing each item.
3. Consumer Function:
   • The consumer function processes items received from the channel.
   • It continuously reads items from the channel until it is closed.
   • It simulates work by sleeping for a random duration after consuming each item.
4. Main Function:
   • A buffered channel is created to hold the items produced by the producers.
   • A sync.WaitGroup is used to wait for all goroutines to finish.
   • Three producer goroutines and two consumer goroutines are started.
   • After all producers finish producing items, the channel is closed to signal the consumers to stop.
   • The program waits for all consumers to finish before printing a completion message.

Concurrency and Synchronization

• The code utilizes Go's goroutines to create and manage concurrent execution for producers and consumers.
• The chan type is used to ensure safe communication between goroutines, allowing producers to send items to consumers without race conditions.
• The sync.WaitGroup is employed to synchronize the completion of goroutines, ensuring that the main function waits for all producers and consumers to finish their tasks.

Example Output

When executed, the program will produce output similar to the following:

javascript

Producer 0 produced item 0
Producer 1 produced item 10
Producer 2 produced item 20
Consumer 0 consumed item 0
Consumer 1 consumed item 10
...
All producers and consumers have finished.

This output demonstrates the interleaved execution of producers and consumers, showcasing the concurrent nature of the program.

Conclusion

This Go code effectively illustrates the producer-consumer problem using goroutines and channels, providing a clear example of concurrent programming in Go. It highlights the importance of synchronization and safe communication when multiple goroutines interact with shared resources, making it a valuable reference for understanding concurrency in Go.

Features:

1. Item Struct:
   • Represents an item produced by the producers.
   • Each item has a unique identifier (id) assigned during initialization.
2. Producer Function:
   • The producer function generates items and sends them to a channel.
   • Each producer creates 5 items, each with a unique ID based on the producer's ID.
   • It simulates work by sleeping for a random duration after producing each item.
3. Consumer Function:
   • The consumer function processes items received from the channel.
   • It continuously reads items from the channel until it is closed.
   • It simulates work by sleeping for a random duration after consuming each item.
4. Main Function:
   • A buffered channel is created to hold the items produced by the producers.
   • A sync.WaitGroup is used to wait for all goroutines to finish.
   • Three producer goroutines and two consumer goroutines are started.
   • After all producers finish producing items, the channel is closed to signal the consumers to stop.
   • The program waits for all consumers to finish before printing a completion message.

Requirements:

Latest release of GoLang installed

Instructions:

For Best results, use Visual Studio Code with appropriate extensions.