生产/消费

产品对象

//产品
public class  Message {
    public static int data;

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

    public int getData() {
        return data;
    }
}

控制中心

//核心
//消息队列类
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.limit = limit;
        this.queue = new LinkedList<>();
    }
    //生产方法
    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 class Producer_Thread extends Thread {

    private final MessageQueue messageQueue;

    private final static AtomicInteger counter = new AtomicInteger(0);
    //通过构造函数,传入消息队列
    public Producer_Thread(MessageQueue messageQueue, int seq) {
        super("++生产线程: " + seq);
        this.messageQueue = messageQueue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                int numb = Message.data++;
                Message message = new Message(numb);
                //塞到消息队列的生产方法
                messageQueue.put(message);
                System.out.println(Thread.currentThread().getName() + " 生产了: " + numb);
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                break;
            }
        }
    }
}

消费线程

public class Consumer_Thread extends Thread {

    private final MessageQueue messageQueue;

    public Consumer_Thread(MessageQueue messageQueue, int seq) {
        super("--消费线程:  " + seq);
        this.messageQueue = messageQueue;
    }

    @Override
    public void run() {
        while (true) {
            try {
                //调用消息队列中的 生产方法
                Message message = messageQueue.take();
                int numb  =  Message.data-1;
                System.out.println(Thread.currentThread().getName() + " 消费线程: " + numb);
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                break;
            }
        }
    }
}

Test_Main

    public static void main(String[] args) {
        final MessageQueue messageQueue = new MessageQueue();
        //生产线程
        new Producer_Thread(messageQueue, 1).start();
        //消费线程
        new Consumer_Thread(messageQueue, 1).start();
    }