简易版消息队列的实现

import java.util.Random;
import java.util.Vector;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.IntStream;

public class Factory {
    volatile Vector<food> list;  // volatile 保证该变量线程之间可见性， Vector是线程安全的
    Lock lock = new ReentrantLock();
     Integer total = 5;
    Condition proCondition = lock.newCondition();
    Condition consCondition = lock.newCondition();

    Factory(Vector list) {
        this.list = list;
    }
    public void produce() throws InterruptedException {
        lock.lock();
        while (list.size()<total) {
            list.add(new food(new Random().nextInt(100)));
            System.out.println("生产食物"+ list.size());
        }
        System.out.println("食物已经满了");
        System.out.println("生产者休眠");
        consCondition.signalAll();
        proCondition.await();
        lock.unlock();
    }
    public void consume() throws InterruptedException {
        lock.lock();
        while (list.size()!=0) {
            list.remove(0); //从队列的头部消费一个消息
            System.out.println("消费食物"+list.size());
        }
        System.out.println("食物消费完了");
        System.out.println("消费者休眠");
        proCondition.signalAll();
        consCondition.await();
        lock.unlock();
    }

    public static void main(String[] args) {

        Factory factory = new Factory(new Vector());
            new Thread(() -> {
                IntStream.range(1,10).forEach(j ->{
                    try {
                        factory.produce();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            }).start();

            new Thread(() -> {
                IntStream.range(1,10).forEach(j->{
                    try {
                        factory.consume();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            }).start();
        }
    class food {
        private int id;
        food(int id){this.id = id;}
    }
}

运行效果

E:\JDK1.8\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2018.2.4\lib\idea_rt.jar=63614:C:\Program Files\JetBrains\IntelliJ IDEA 2018.2.4\bin" -Dfile.encoding=UTF-8 -classpath E:\JDK1.8\jre\lib\charsets.jar;E:\JDK1.8\jre\lib\deploy.jar;E:\JDK1.8\jre\lib\ext\access-bridge-64.jar;E:\JDK1.8\jre\lib\ext\cldrdata.jar;E:\JDK1.8\jre\lib\ext\dnsns.jar;E:\JDK1.8\jre\lib\ext\jaccess.jar;E:\JDK1.8\jre\lib\ext\jfxrt.jar;E:\JDK1.8\jre\lib\ext\localedata.jar;E:\JDK1.8\jre\lib\ext\nashorn.jar;E:\JDK1.8\jre\lib\ext\sunec.jar;E:\JDK1.8\jre\lib\ext\sunjce_provider.jar;E:\JDK1.8\jre\lib\ext\sunmscapi.jar;E:\JDK1.8\jre\lib\ext\sunpkcs11.jar;E:\JDK1.8\jre\lib\ext\zipfs.jar;E:\JDK1.8\jre\lib\javaws.jar;E:\JDK1.8\jre\lib\jce.jar;E:\JDK1.8\jre\lib\jfr.jar;E:\JDK1.8\jre\lib\jfxswt.jar;E:\JDK1.8\jre\lib\jsse.jar;E:\JDK1.8\jre\lib\management-agent.jar;E:\JDK1.8\jre\lib\plugin.jar;E:\JDK1.8\jre\lib\resources.jar;E:\JDK1.8\jre\lib\rt.jar;E:\mydataStructure\out\production\mydataStructure Factory
生产食物1
生产食物2
生产食物3
生产食物4
生产食物5
食物已经满了
生产者休眠
消费食物4
消费食物3
消费食物2
消费食物1
消费食物0
食物消费完了
消费者休眠
生产食物1
生产食物2
生产食物3
生产食物4
生产食物5
食物已经满了
生产者休眠
消费食物4
消费食物3
消费食物2
消费食物1
消费食物0
食物消费完了
消费者休眠
生产食物1
生产食物2
生产食物3
生产食物4
生产食物5
食物已经满了
生产者休眠
消费食物4
消费食物3
消费食物2
消费食物1
消费食物0
食物消费完了
消费者休眠
生产食物1
生产食物2
生产食物3
生产食物4
生产食物5
食物已经满了
生产者休眠
消费食物4
消费食物3
消费食物2
消费食物1
消费食物0
食物消费完了
消费者休眠
生产食物1
生产食物2
生产食物3
生产食物4
生产食物5
食物已经满了
生产者休眠
消费食物4
消费食物3
消费食物2
消费食物1
消费食物0
食物消费完了
消费者休眠
生产食物1
生产食物2
生产食物3
生产食物4
生产食物5
食物已经满了
生产者休眠
消费食物4
消费食物3
消费食物2
消费食物1
消费食物0
食物消费完了
消费者休眠
生产食物1
生产食物2
生产食物3
生产食物4
生产食物5
食物已经满了
生产者休眠
消费食物4
消费食物3
消费食物2
消费食物1
消费食物0
食物消费完了
消费者休眠
生产食物1
生产食物2
生产食物3
生产食物4
生产食物5
食物已经满了
生产者休眠
消费食物4
消费食物3
消费食物2
消费食物1
消费食物0
食物消费完了
消费者休眠
生产食物1
生产食物2
生产食物3
生产食物4
生产食物5
食物已经满了
生产者休眠
消费食物4
消费食物3
消费食物2
消费食物1
消费食物0
食物消费完了
消费者休眠

简易版消息队列的实现_消息队列