Write a Java program that correctly implements the producer - consumer problem using the concept of inter-thread communication. (use of synchronize)

Write a Java program that correctly implements the producer - consumer problem using the concept of inter-thread communication. (use of synchronize)

2. import java.util.LinkedList;
3. 
   
4. public class Main {
5.     public static void main(String[] args) {
6.         // Create a shared buffer
7.         LinkedList<Integer> buffer = new LinkedList<>();
8.         int capacity = 5;
9. 
   
10.         // Create the producer and consumer threads
11.         Thread producer = new Thread(new Producer(buffer, capacity));
12.         Thread consumer = new Thread(new Consumer(buffer, capacity));
13. 
    
14.         // Start the threads
15.         producer.start();
16.         consumer.start();
17.     }
18. }
19. 
    
20. // The producer thread that adds items to the buffer
21. class Producer implements Runnable {
22.     private LinkedList<Integer> buffer;
23.     private int capacity;
24. 
    
25.     public Producer(LinkedList<Integer> buffer, int capacity) {
26.         this.buffer = buffer;
27.         this.capacity = capacity;
28.     }
29. 
    
30.     public void run() {
31.         for (int i = 1; i <= 10; i++) {
32.             synchronized (buffer) {
33.                 while (buffer.size() == capacity) {
34.                     try {
35.                         System.out.println("Buffer is full. Producer waiting...");
36.                         buffer.wait();
37.                     } catch (InterruptedException e) {
38.                         e.printStackTrace();
39.                     }
40.                 }
41. 
    
42.                 buffer.add(i);
43.                 System.out.println("Produced: " + i);
44.                 buffer.notifyAll();
45.             }
46.         }
47.     }
48. }
49. 
    
50. // The consumer thread that removes items from the buffer
51. class Consumer implements Runnable {
52.     private LinkedList<Integer> buffer;
53.     private int capacity;
54. 
    
55.     public Consumer(LinkedList<Integer> buffer, int capacity) {
56.         this.buffer = buffer;
57.         this.capacity = capacity;
58.     }
59. 
    
60.     public void run() {
61.         while (true) {
62.             synchronized (buffer) {
63.                 while (buffer.isEmpty()) {
64.                     try {
65.                         System.out.println("Buffer is empty. Consumer waiting...");
66.                         buffer.wait();
67.                     } catch (InterruptedException e) {
68.                         e.printStackTrace();
69.                     }
70.                 }
71. 
    
72.                 int item = buffer.remove();
73.                 System.out.println("Consumed: " + item);
74.                 buffer.notifyAll();
75.             }
76.         }
77.     }
78. }

Givan by -Ujjwal Matoliya