多线程设计模式-生产者消费者模式（Proudcer-consumer）

生产者消费者模式（Proudcer-consumer）

多线程共享资源，生产者生产到消息队列中（大小限制），消费者从中消费消费数据，如果生产者过快，当满了队列后，生产者休眠，如果队列为空，消费者休眠

消息体

package com.ln.concurrent.chapter13;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter13
 * @Name:Message
 * @Author:linianest
 * @CreateTime:2021/1/3 17:38
 * @version:1.0
 * @Description TODO: 消息体
 */
public class Message {

    private String data;

    public Message(String data) {
        this.data = data;
    }

    public String getData() {
        return data;
    }

}

消息队列:有大小限制

package com.ln.concurrent.chapter13;

import java.util.LinkedList;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter13
 * @Name:MessageQueue
 * @Author:linianest
 * @CreateTime:2021/1/3 17:38
 * @version:1.0
 * @Description TODO: 消息队列:有大小限制
 */
public class MessageQueue {

    private final LinkedList<Message> queue;
    // 设置消息队列大小
    private final static int DEFAULT_MAX_LIMIT = 100;
    private final int limit;

    public MessageQueue() {
        this(DEFAULT_MAX_LIMIT);
    }

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

    public void put(final Message message) throws InterruptedException {
        synchronized (queue) {
            while (queue.size() > limit) {
                queue.wait();
            }
            queue.addLast(message);
            queue.notifyAll();
        }
    }

    public Message take() throws InterruptedException {
        synchronized (queue) {
            while (queue.isEmpty()) {
                queue.wait();
            }
            Message message = queue.removeFirst();
            queue.notifyAll();
            return message;
        }
    }

    public int getMaxLimit() {
        return this.limit;
    }

    public int getMessageSize() {
        synchronized (queue) {
            return queue.size();
        }
    }
}

生产者

package com.ln.concurrent.chapter13;

import java.util.Random;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter13
 * @Name:ProudcerThread
 * @Author:linianest
 * @CreateTime:2021/1/3 17:54
 * @version:1.0
 * @Description TODO: 生产者
 */
public class ProdcerThread extends Thread {
    private final MessageQueue messageQueue;

    public static final Random random = new Random(System.currentTimeMillis());

    // 具有原子性的计数器
    private final static AtomicInteger counter = new AtomicInteger(0);

    public ProdcerThread(MessageQueue messageQueue, int seq
    ) {
        // 设置线程的名称
        super("PRODUCER-" + seq);
        this.messageQueue = messageQueue;
    }


    @Override
    public void run() {
        while (true) {
            try {
                Message message = new Message("Message-" + counter.getAndIncrement());
                messageQueue.put(message);
                System.out.println(Thread.currentThread().getName() + " put message " + message.getData());
                Thread.sleep(random.nextInt(1_000));
            } catch (InterruptedException e) {
                break;
            }
        }
    }
}

消费者

package com.ln.concurrent.chapter13;

import java.util.Random;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter13
 * @Name:ComsumerThread
 * @Author:linianest
 * @CreateTime:2021/1/3 18:03
 * @version:1.0
 * @Description TODO: 消费者
 */
public class ConsumerThread extends Thread {

    private final MessageQueue messageQueue;

    public static final Random random = new Random(System.currentTimeMillis());

    // 具有原子性的计数器
    private final static AtomicInteger counter = new AtomicInteger(0);

    public ConsumerThread(MessageQueue messageQueue, int seq
    ) {
        // 设置线程的名称
        super("Consumer-" + seq);
        this.messageQueue = messageQueue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Message message = messageQueue.take();
                System.out.println(Thread.currentThread().getName() + " take message " + message.getData());
                Thread.sleep(random.nextInt(1_000));
            } catch (InterruptedException e) {
                break;
            }
        }
    }
}

客户端

package com.ln.concurrent.chapter13;

import java.util.stream.IntStream;

/**
 * @ProjectName: java-concurrency
 * @Package: com.ln.concurrent.chapter13
 * @Name:ProducerAndConsumerThread
 * @Author:linianest
 * @CreateTime:2021/1/3 18:06
 * @version:1.0
 * @Description TODO: 客户端
 */
public class ProducerAndConsumerThread {
    public static void main(String[] args) {
        final MessageQueue messageQueue=new MessageQueue();
        IntStream.range(1,3).forEach(i->{
            new ProdcerThread(messageQueue,i).start();
        });
        IntStream.range(1,2).forEach(i->{
            new ConsumerThread(messageQueue,i).start();
        });
    }
}