Producer consumer model of concurrent programming

What problems do producers and consumers solve ？

1. Synchronization between multiple threads problem .
2. Solve the problems of producers and consumers Strong coupling problem .

---

Reference code ：

package Top;

import java.util.LinkedList;
import java.util.Random;

/** * @Author 86180 * @Date 2020/9/7 21:50 * @Version 1.0 **/
public class ProductorConsumer {
    

    public static void main(String[] args) {
    
        MessageQueue messageQueue = new MessageQueue(2);
        for(int i = 0; i < 3; i++){
    
            new Thread(new Productor(messageQueue, new Message(i, " news i")), " Producer thread "+i).start();
        }
        for(int i = 0; i < 1; i++){
    
            new Thread(new Consumer(messageQueue), " Consumer thread "+i).start();
        }
    }

}

class MessageQueue{
    
    private int capacity;
    LinkedList<Message> list;
    MessageQueue(int capacity){
    
        list = new LinkedList<>();
        this.capacity = capacity;
    }

    public synchronized void put(Message message){
    


                    while (list.size() == capacity) {
    
                        try {
    
                            System.out.println(" The queue is full , Producer waiting .");
                            this.wait();
                        } catch (InterruptedException e) {
    
                            e.printStackTrace();
                        }
                    }
                    // If you use if To judge , Pay attention to the order ： Put it in addLast front 
                    if(list.isEmpty())this.notifyAll();

                    list.addLast(message);
                    System.out.println(Thread.currentThread().getName()+" Produced " + message.getId());



    }

    public synchronized Message get(){
    


                while(list.isEmpty()){
    
                    try {
    
                        System.out.println(" The queue is empty , Producer thread waiting .");
                        this.wait();
                    } catch (InterruptedException e) {
    
                        e.printStackTrace();
                    }
                }

                if(list.size() == capacity)this.notifyAll();// If you use if To judge , Pay attention to the order ： Put it in removeFirst front 

                Message message = list.removeFirst();
                System.out.println(Thread.currentThread().getName()+" The consumption "+ message.getId());
                return message;


    }
}

class Productor implements Runnable{
    
    MessageQueue ms;
    Message message;
    Productor(MessageQueue messageQueue, Message message){
    
        this.ms = messageQueue;
        this.message = message;
    }
    @Override
    public void run() {
    
        while(true) {
    
            try {
    
                Thread.sleep(new Random().nextInt(100));
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
            ms.put(message);
        }
    }
}


class Consumer implements Runnable{
    
    MessageQueue ms;
    Consumer(MessageQueue messageQueue){
    
        this.ms = messageQueue;
    }

    @Override
    public void run() {
    
        while(true) {
    
            try {
    
                Thread.sleep(new Random().nextInt(100));
            } catch (InterruptedException e) {
    
                e.printStackTrace();
            }
            ms.get();
        }

    }
}

class Message{
    
        private int id;
        private Object value;
        Message(int id, Object value){
    
            this.id = id;
            this.value = value;
        }
        public int getId(){
    
            return id;
        }
}

Define a Message class , Indicates the messages stored in the message queue .
Define a MessageQueue class , contain put() and get().
Define a producer class Productor.
Define a consumer class Consumer.