Threading in Ruby

Description:

This Ruby code implements a simple producer-consumer model using threads and a thread-safe queue. The program simulates the production and consumption of items, demonstrating how multiple producers can generate items concurrently while multiple consumers process those items.

Key Components

1. Item Class:
   • Represents an item produced by the producers.
   • Each item has a unique identifier (id) assigned during initialization.
2. Producer Class:
   • Responsible for creating items and adding them to a shared queue.
   • Each producer generates 5 items, with unique IDs based on the producer's ID.
   • The produce method simulates work by sleeping for a random duration after producing each item.
3. Consumer Class:
   • Responsible for consuming items from the shared queue.
   • The consume method continuously attempts to pop items from the queue until no more items are available.
   • It simulates work by sleeping for a random duration after consuming each item.
4. Main Execution:
   • A thread-safe queue is created to hold the items produced by the producers.
   • Three producer threads and two consumer threads are started.
   • After all producers finish producing items, nil values are added to the queue to signal the consumers to stop.
   • The program waits for all consumer threads to finish before printing a completion message.

Threading and Synchronization

• The code utilizes Ruby's Thread class to create and manage multiple threads for producers and consumers.
• The Queue class is used to ensure thread-safe operations when adding and removing items, preventing race conditions.

Example Output

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

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 Ruby code effectively illustrates the producer-consumer problem using threads and a synchronized queue, providing a clear example of concurrent programming in Ruby. It highlights the importance of thread safety and synchronization when multiple threads interact with shared resources.

Features:

1. Item Class:
   • Represents an item produced by the producers.
   • Each item has a unique identifier (id) assigned during initialization.
2. Producer Class:
   • Responsible for creating items and adding them to a shared queue.
   • Each producer generates 5 items, with unique IDs based on the producer's ID.
   • The produce method simulates work by sleeping for a random duration after producing each item.
3. Consumer Class:
   • Responsible for consuming items from the shared queue.
   • The consume method continuously attempts to pop items from the queue until no more items are available.
   • It simulates work by sleeping for a random duration after consuming each item.
4. Main Execution:
   • A thread-safe queue is created to hold the items produced by the producers.
   • Three producer threads and two consumer threads are started.
   • After all producers finish producing items, nil values are added to the queue to signal the cons

Requirements:

Install the latest version of Ruby

Instructions:

To get the best result possibe, use Visual Studio Code.