[hand tearing code] single case mode and producer / consumer mode

The singleton pattern

  The singleton pattern （Singleton Pattern）: Ensure that a class has only one object , And provide a global access point to access it .

Advantages of singleton mode ：

• Because the singleton mode only generates one instance , Reduced system performance overhead , When more resources are needed to generate an object , Such as read configuration 、 When other dependent objects are generated , You can start... In the application Directly generate a singleton object , Then permanent resident memory to solve
• The singleton mode can set the global access point in the system , Optimize ring shared resource access , For example, you can design A singleton class , Responsible for the mapping of all data tables  

Code implementation ：

Hungry Chinese style ： Create before use , Thread safety , Take up memory .

public class SingleClassA {

    //1. Privatized construction method , So that this method cannot be called outside the class , Limit the generation of multiple objects 
    private SingleClassA(){ }
    //2. Create an instance of the class inside the class 
    // Class initialization , Load this object now （ There is no advantage of delayed loading ）. When loading a class , Naturally, it's thread safe ！
    private static final SingleClassA instance = new SingleClassA();
    //3. Call methods to external providers ： Return the created object to , Can only be called through a class 
    // Method is not synchronized , High call efficiency ！
    public static SingleClassA  getInstance(){
        return instance;
    }

    public static void main(String[] args) {
        SingleClassA a = getInstance();
        SingleClassA b = getInstance();
        System.out.println(a == b);
    }
}

Output results ：

  Slacker type ： Created when used , Thread unsafe （ When creating or getting a singleton object ）, Locking will affect efficiency .

public class SingleClassB {

        //1. Privatized construction method , So that this method cannot be called outside the class , Limit the generation of multiple objects 
        private SingleClassB(){ }
        //2. Create an instance of the class inside the class 
        private static SingleClassB instance ;
        //3. Call methods to external providers ： Return the created object to , Can only be called through a class 
        public static synchronized SingleClassB  getInstance(){
            if(instance == null) {
                instance = new SingleClassB();
            }
            return instance;
        }

        // test 
        public static void main(String[] args) {
            SingleClassB a = SingleClassB.getInstance();
            SingleClassB b = SingleClassB.getInstance();
            System.out.println(a==b);
        }
    }

Output results ：

The difference between lazy man mode and hungry man mode ：

1. Lazy style will not instantiate by default , Wait until the method is called externally before , The object is instantiated in the hungry class loading stage
2. Thread safe , Hungry man style must be thread safe , Because the object was instantiated before the thread appeared , Lazy is thread unsafe , Because in multithreading , If a thread judges that the finished instance is null Sleep or interrupt , Then another thread also enters the method , The judgment example is also null, Then the thread will create an instance object , After the original dormant thread resumes , Execute instantiation directly new Object step , Then there will be multiple instances .
3. Analyze the thread safety above , Next is performance , Maybe you already have , The hungry man style doesn't need to be locked , High execution efficiency , Lazy style needs to be locked , Inefficient execution
4. Occupy memory , Hungry man style whether you use its instance object or not , He was instantiated there from the beginning , Occupy memory space , The lazy type is instantiated only when it is used , It doesn't waste memory

producer / Consumer model

The producer-consumer pattern solves the problem of strong coupling between producer and consumer through a container . Producers and consumers do not communicate directly with each other , Instead, it communicates by blocking the queue , So producers don't have to wait for consumers to process their data , Throw it directly into the blocking queue , Consumers don't ask producers for data , I'm going to take it directly from the blocking queue , Blocking a queue is like a buffer , Balancing the processing power of producers and consumers . As shown in the figure below ：

  Code implementation ：

@Slf4j(topic = "ProductAndConsumer")
public class ProductAndConsumer {
    public static void main(String[] args) {
        MessageQueue messageQueue = new MessageQueue(2);
// 3  Producer threads 
        for (int i = 0; i < 3; i++) {
            int id = i;
            new Thread(() -> {
                messageQueue.put(new Message(id, " value " + id));
            }, " producer " + i).start();
        }
// 1  Consumer threads ,  Processing results 
        new Thread(() -> {
            while (true) {
                try {
                    sleep(1000);
                    Message message = messageQueue.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, " consumer ").start();
    }
}


final class Message {
    private int id;
    private Object message;

    public Message(int id, Object message) {
        this.id = id;
        this.message = message;
    }
    public int getId() {
        return id;
    }
    public Object getMessage() {
        return message;
    }

    @Override
    public String toString() {
        return "Message{" +
                "id=" + id +
                ", message=" + message +
                '}';
    }
}

@Slf4j(topic = "MessageQueue")
class MessageQueue {
    private LinkedList<Message> queue;
    private int capacity;

    public MessageQueue(int capacity) {
        this.capacity = capacity;
        queue = new LinkedList<>();
    }

    public Message take() {
        synchronized (queue) {
            while (queue.isEmpty()) {
                log.debug(" The queue is empty , Consumer thread waiting ");
                try {
                    queue.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            Message message = queue.removeFirst();
            log.debug(" Consumed news {}",message);
            queue.notifyAll();
            return message;
        }
    }

    public void put(Message message) {
        synchronized (queue) {
            while (queue.size() == capacity) {
                try {
                    log.debug(" Inventory has reached the upper limit ,  Producer thread waiting ");
                    queue.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            queue.addLast(message);
            log.debug(" The message has been produced {}",message);
            queue.notifyAll();
        }
    }
}

The output is as follows ：