In computing, the producer–consumer problem (also known as the bounded-buffer problem) is a classic example of a multi-process synchronization problem. The problem describes two processes, the producer and the consumer, which share a common, fixed-size buffer used as a queue.

• The producer’s job is to generate data, put it into the buffer, and start again.
• At the same time, the consumer is consuming the data (i.e. removing it from the buffer), one piece at a time.

Recommended Reading- Multithreading in JAVA ,Synchronized in JAVA , Inter-thread Communication

Implementation of Producer Consumer Class

• A LinkedList list – to store list of jobs in queue.
• A Variable Capacity – to check for if the list is full or not
• A mechanism to control the insertion and extraction from this list so that we do not insert into list if it is full or remove from it if it is empty.

Note: It is recommended to test the below program on a offline IDE as infinite loops and sleep method may lead to it time out on any online IDE

// Java program to implement solution of producer // consumer problem. import java.util.LinkedList;  public class Threadexample {     public static void main(String[] args)                         throws InterruptedException     {         // Object of a class that has both produce()         // and consume() methods         final PC pc = new PC();          // Create producer thread         Thread t1 = new Thread(new Runnable()         {             @Override             public void run()             {                 try                 {                     pc.produce();                 }                 catch(InterruptedException e)                 {                     e.printStackTrace();                 }             }         });          // Create consumer thread         Thread t2 = new Thread(new Runnable()         {             @Override             public void run()             {                 try                 {                     pc.consume();                 }                 catch(InterruptedException e)                 {                     e.printStackTrace();                 }             }         });          // Start both threads         t1.start();         t2.start();          // t1 finishes before t2         t1.join();         t2.join();     }      // This class has a list, producer (adds items to list     // and consumber (removes items).     public static class PC     {         // Create a list shared by producer and consumer         // Size of list is 2.         LinkedList<Integer> list = new LinkedList<>();         int capacity = 2;          // Function called by producer thread         public void produce() throws InterruptedException         {             int value = 0;             while (true)             {                 synchronized (this)                 {                     // producer thread waits while list                     // is full                     while (list.size()==capacity)                         wait();                      System.out.println("Producer produced-"                                                   + value);                      // to insert the jobs in the list                     list.add(value++);                      // notifies the consumer thread that                     // now it can start consuming                     notify();                      // makes the working of program easier                     // to  understand                     Thread.sleep(1000);                 }             }         }          // Function called by consumer thread         public void consume() throws InterruptedException         {             while (true)             {                 synchronized (this)                 {                     // consumer thread waits while list                     // is empty                     while (list.size()==0)                         wait();                      //to retrive the ifrst job in the list                     int val = list.removeFirst();                      System.out.println("Consumer consumed-"                                                     + val);                      // Wake up producer thread                     notify();                      // and sleep                     Thread.sleep(1000);                 }             }         }     } }

Output:

Producer produced-0 Producer produced-1 Consumer consumed-0 Consumer consumed-1 Producer produced-2

Important Points

• In PC class (A class that has both produce and consume methods), a linked list of jobs and a capacity of the list is added to check that producer does not produce if the list is full.
• In Producer class , the value is initialized as 0.
  • Also, we have an infinite outer loop to insert values in the list. Inside this loop, we have a synchronized block so that only a producer or a consumer thread runs at a time.
  • An inner loop is there before adding the jobs to list that checks if the job list is full, the producer thread gives up the intrinsic lock on PC and goes on the waiting state.
  • If the list is empty, the control passes to below the loop and it adds a value in the list.

Exercise :

• Readers are advised to use if condition in place of inner loop for checking boundary conditions.
• Try to make your program produce one item and immediately after that the consumer consumes it before any other item is produced by the consumer.

Reference – https://en.wikipedia.org/wiki/Producer%E2%80%93consumer_problem

This article is contributed by Rishabh Mahrsee . If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.