一心多用多线程-阻塞队列（2）-PriorityBlockingQueue

た入场券 2022-07-15 04:29 169阅读 0赞

**二、可根据优先级自动出菜的选菜区PriorityBlockingQueue**  
在现实中啊，在同等同质的产品中，人们往往会选择价格低的进行购买，PriorityBlockingQueue是一个聪明的队列，只要你告诉他一个资源的排序规则，它就会根据你给的规则定义资源被消耗的顺序（而不是以前的先进先出），要注意的一点是PriorityBlockingQueue是一个无界的队列，也就是说如果你的生产者速度一直快于消耗着的话，那么系统资源将会被消耗完，有OOM的危险。

现在进入一个情景，想象厨师做出来的肠粉是有不同的价格的，然而人们会首选低价的肠粉进行食用，通过代码来模拟这个过程

public  class PriorityBlockingQueueTest {
        public static class Fen implements Comparable<Fen>{
       //模拟一个资源，是一个粉，构造的时候输入价格，价格越高越快被消耗
            private int priority=0;
            private String name = "";
            public Fen(int priority,String name){
                this.priority=priority;
                this.name="$"+priority+":"+name;
            }
            public int  getPriority(){
                return priority;
            }
            public String getName(){
                return name;
            }
            @Override
            public int compareTo(Fen o) {
                return this.getPriority()-o.getPriority();//降序，priority低的先被消耗
            }
    
        }
    
        public static void main(String[] args){
            PriorityBlockingQueue<Fen> valve = new PriorityBlockingQueue<Fen>();
            Thread fenOffer  = new Thread(new Runnable() {
    
                @Override
                public void run() {
                    while(true){
                        int random = new Random().nextInt(10);
                        Fen fen =new PriorityBlockingQueueTest.Fen(random,"一盘肠粉");
                        valve.put(fen);
                        System.out.println("生成了"+fen.getName());
                        try {
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
    
            Thread fenConsumer = new Thread(new Runnable() {
                @Override
                public void run() {
                    while(true){
                        Fen f = null;
                        try {
                            f = valve.take();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println("------消耗了"+f.getName());
                        try {
                            Thread.sleep(5000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
            fenConsumer.start();
            fenOffer.start();
        }
    }

结果：

生成了$1:一盘肠粉
    ------消耗了$1:一盘肠粉
    生成了$8:一盘肠粉
    生成了$5:一盘肠粉
    ------消耗了$5:一盘肠粉
    生成了$2:一盘肠粉
    生成了$3:一盘肠粉
    ------消耗了$2:一盘肠粉
    生成了$1:一盘肠粉
    生成了$9:一盘肠粉
    生成了$7:一盘肠粉
    ------消耗了$1:一盘肠粉
    生成了$3:一盘肠粉
    生成了$2:一盘肠粉
    ------消耗了$2:一盘肠粉
    生成了$1:一盘肠粉
    生成了$6:一盘肠粉
    生成了$6:一盘肠粉
    ------消耗了$1:一盘肠粉
    生成了$7:一盘肠粉
    生成了$6:一盘肠粉