zoukankan      html  css  js  c++  java
  • 并发编程-concurrent指南-阻塞双端队列-链阻塞双端队列LinkedBlockingDeque

    LinkedBlockingDeque是双向链表实现的阻塞队列。该阻塞队列同时支持FIFO和FILO两种操作方式,即可以从队列的头和尾同时操作(插入/删除);

    在不能够插入元素时,它将阻塞住试图插入元素的线程;在不能够抽取元素时,它将阻塞住试图抽取的线程。;

    LinkedBlockingDeque还是可选容量的,防止过度膨胀,默认等于Integer.MAX_VALUE。;

    LinkedBlockingDueue没有进行读写锁的分离,因此同一时间只能有一个线程对其操作,因此在高并发应用中,它的性能要远远低于LinkedBlockingQueue

    具体代码:

    import java.util.concurrent.LinkedBlockingDeque;
    
    public class Main {
        public static void main(String[] args) {
            //给个3的队列
            LinkedBlockingDeque<Integer> linkedBlockingDeque = new LinkedBlockingDeque<Integer>(3);
    
            //生产者
            Producer firstProducer = new FirstProducer(linkedBlockingDeque);//头部插入
            Producer lastProducer = new LastProducer(linkedBlockingDeque);//尾部插入
            firstProducer.start();
    //        lastProducer.start();
    
    
            //消费者
            Consumer firstConsumer = new FirstConsumer(linkedBlockingDeque);//头部获取
            Consumer lastConsumer = new LastConsumer(linkedBlockingDeque);//尾部获取
    //        firstConsumer.start();
            lastConsumer.start();
    
        }
    }
    import java.util.Random;
    import java.util.concurrent.LinkedBlockingDeque;
    
    /**
     * 生产者
     */
    public abstract class Producer extends Thread{
        protected LinkedBlockingDeque<Integer> linkedBlockingDeque;
        public Producer(LinkedBlockingDeque<Integer> linkedBlockingDeque){
            this.linkedBlockingDeque = linkedBlockingDeque;
        }
    
        @Override
        public void run() {
            while(true){
                int random = new Random().nextInt(1000);
                try {
                    this.putQueue(random);//插入数据
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public abstract void putQueue(int random) throws InterruptedException;
    }
    import java.util.concurrent.LinkedBlockingDeque;
    
    /**
     * 头部插入
     */
    public class FirstProducer extends Producer{
        public FirstProducer(LinkedBlockingDeque<Integer> linkedBlockingDeque) {
            super(linkedBlockingDeque);
        }
    
        @Override
        public void putQueue(int random) throws InterruptedException {
            System.out.println("头部生产产品:"+random);
            super.linkedBlockingDeque.putFirst(random);
            System.out.println("头部生产产品:"+random+",结束");
        }
    }
    import java.util.concurrent.LinkedBlockingDeque;
    
    /**
     * 尾部插入:默认是尾部插入
     */
    public class LastProducer extends Producer{
        public LastProducer(LinkedBlockingDeque<Integer> linkedBlockingDeque) {
            super(linkedBlockingDeque);
        }
    
        @Override
        public void putQueue(int random) throws InterruptedException {
            super.linkedBlockingDeque.putLast(random);
        }
    }
    import java.util.concurrent.LinkedBlockingDeque;
    
    /**
     * 消费者
     */
    public abstract class Consumer extends Thread{
        protected LinkedBlockingDeque<Integer> linkedBlockingDeque;
        public Consumer(LinkedBlockingDeque<Integer> linkedBlockingDeque){
            this.linkedBlockingDeque = linkedBlockingDeque;
        }
    
        @Override
        public void run() {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("------------------------------------");
            while(true){
                try {
                    System.out.println("尾部等待3秒开始获取产品");
                    Thread.sleep(3000);
                    this.takeQueue();//获取数据
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
        public abstract void takeQueue() throws InterruptedException;
    }
    import java.util.concurrent.LinkedBlockingDeque;
    
    /**
     * 头部获取
     */
    public class FirstConsumer extends Consumer{
        public FirstConsumer(LinkedBlockingDeque<Integer> linkedBlockingDeque) {
            super(linkedBlockingDeque);
        }
    
        @Override
        public void takeQueue() throws InterruptedException {
            System.out.println("头部获取产品开始");
            Integer random = super.linkedBlockingDeque.takeFirst();
            System.out.println("头部获取产品:"+random+",结束");
        }
    }
    import java.util.concurrent.LinkedBlockingDeque;
    
    /**
     * 尾部获取
     */
    public class LastConsumer extends Consumer{
        public LastConsumer(LinkedBlockingDeque<Integer> linkedBlockingDeque) {
            super(linkedBlockingDeque);
        }
    
        @Override
        public void takeQueue() throws InterruptedException {
            Integer random = super.linkedBlockingDeque.takeLast();
            System.out.println("尾部获取产品:"+random+",结束");
        }
    }

    源码地址:https://github.com/qjm201000/concurrent_linkedBlockingDeque.git

  • 相关阅读:
    【转载】Highcharts一些属性
    What is assembly?
    用Apache配置Git服务器
    【转】.NET试题总结二
    【转】SVN服务器的快速搭建。
    【转】.NET试题总结一
    【转】国外C#开源系统一览表 ,C# Open Source
    Amazon S3 REST方式获取Object
    Action Filter
    a 标签 name 熟悉因为头部固定,导致置顶遮挡解决方案
  • 原文地址:https://www.cnblogs.com/qjm201000/p/10146504.html
Copyright © 2011-2022 走看看