JAVA并发-TransferQueue队列

一、队列

0. 队列基本概念

队列(queue)是一种是相对于栈的一种数据结构,它是先进先出(First In First Out)。
它只可以在尾部添加元素。

  • 双端队列
    双端队列(deque double ended queue(双端队列))是一种相对于队列的一种数据结构。它可以在尾部和头部插入、移除和获取。

  • 阻塞队列
    阻塞队列是一个在队列基础上又支持了两个附加操作的队列。

    • 支持阻塞的插入方法:队列满时,队列会阻塞插入元素的线程,直到队列不满。
    • 支持阻塞的移除方法:队列空时,获取元素的线程会等待队列变为非空。

1. java队列

在这里插入图片描述Queue: 基本上,一个队列就是一个先入先出(FIFO)的数据结构

Queue接口与List、Set同一级别,都是继承了Collection接口。

队列(queue)是一种是相对于栈的一种数据结构,它是先进先出(First In First Out)。
它只可以在尾部添加元素。

2. java阻塞队列

Java 中总的算起来有 8 种阻塞队列。
在这里插入图片描述
在生产者消费者模型中,生产数据和消费数据的速率不一致,如果生产数据速度快一些,消费(处理)不过来,就会导致数据丢失。这时候我们就可以应用上阻塞队列来解决这个问题。

阻塞队列首先是一个队列,一般我们起单线程生产数据入队,起多线程消费数据。

由于阻塞队列的特点:队空时消费阻塞,队满时生产阻塞。多线程消费数据起到了加速消费的作用,使得生产的数据不会在队里积压过多,而生产的数据也不会丢失处理了。

当我们身在分布式开发中时经常会碰到突然大量的消息造访,而我们的消费者无法及时处理,最终导致消息丢失,甚至服务崩溃。这个时候我们就需要暂时将这些不速之客请到“休息室”去坐一下。

阻塞队列BlockingQueue就是我们经常使用的“休息室”。阻塞队列可以有效的阻止大量的消息冲击我们的服务,设置队列大小可以将无法处理的消息阻止在外。

二、 什么是TransferQueue

并发编程—— LinkedTransferQueue
参考URL: https://www.jianshu.com/p/ae6977886cec

JDK7对JDK5中的J.U.C并发工具进行了增强,其中之一就是新增了TransferQueue。

public interface TransferQueue<E> extends BlockingQueue<E>

从类的源码可以看到TransferQueue同时也是一个阻塞队列,它具备阻塞队列的所有特性。

TransferQueue继承关系
在这里插入图片描述
TransferQueue(java7引入)继承了BlockingQueue(BlockingQueue又继承了Queue)并扩展了一些新方法。生产者会一直阻塞直到所添加到队列的元素被某一个消费者所消费(不仅仅是添加到队列里就完事)。

该类实现了一个 TransferQueue。该接口定义了几个方法:

public interface TransferQueue<E> extends BlockingQueue<E> {
    // 如果可能,立即将元素转移给等待的消费者。 
    // 更确切地说,如果存在消费者已经等待接收它(在 take 或 timed poll(long,TimeUnit)poll)中,则立即传送指定的元素,否则返回 false。
    boolean tryTransfer(E e);

    // 将元素转移给消费者,如果需要的话等待。 
    // 更准确地说,如果存在一个消费者已经等待接收它(在 take 或timed poll(long,TimeUnit)poll)中,则立即传送指定的元素,否则等待直到元素由消费者接收。
    void transfer(E e) throws InterruptedException;

    // 上面方法的基础上设置超时时间
    boolean tryTransfer(E e, long timeout, TimeUnit unit) throws InterruptedException;

    // 如果至少有一位消费者在等待,则返回 true
    boolean hasWaitingConsumer();

    // 返回等待消费者人数的估计值
    int getWaitingConsumerCount();
}

阻塞队列不外乎put ,take,offer ,poll等方法,再加上TransferQueue的 几个 tryTransfer 方法。

  • transfer(E e)若当前存在一个正在等待获取的消费者线程,即立刻将e移交之;否则将元素e插入到队列尾部,并且当前线程进入阻塞状态,直到有消费者线程取走该元素。

  • tryTransfer(E e)若当前存在一个正在等待获取的消费者线程,则该方法会即刻转移e,并返回true;若不存在则返回false,但是并不会将e插入到队列中。这个方法不会阻塞当前线程,要么快速返回true,要么快速返回false。

  • hasWaitingConsumer()和getWaitingConsumerCount()用来判断当前正在等待消费的消费者线程个数。

  • tryTransfer(E e, long timeout, TimeUnit unit) 若当前存在一个正在等待获取的消费者线程,会立即传输给它; 否则将元素e插入到队列尾部,并且等待被消费者线程获取消费掉。若在指定的时间内元素e无法被消费者线程获取,则返回false,同时该元素从队列中移除。

1. LinkedTransferQueue性能

BlockingQueue对读或者写都是锁上整个队列,在并发量大的时候,各种锁是比较耗资源和耗时间的,而前面的SynchronousQueue虽然不会锁住整个队列,但它是一个没有容量的“队列”,那么有没有这样一种队列,它即可以像其他的BlockingQueue一样有容量又可以像SynchronousQueue一样不会锁住整个队列呢?有!答案就是LinkedTransferQueue。

LinkedTransferQueue是基于链表的FIFO无界阻塞队列,它出现在JDK7中。Doug Lea 大神说LinkedTransferQueue是一个聪明的队列。它是ConcurrentLinkedQueue、SynchronousQueue (公平模式下)、无界的LinkedBlockingQueues等的超集。

三、TransferQueue应用场景

当我们不想生产者过度生产消息时,TransferQueue可能非常有用,可避免发生OutOfMemory错误。在这样的设计中,消费者的消费能力将决定生产者产生消息的速度。

public class LinkedTransferQueueDemo {
    static LinkedTransferQueue<String> lnkTransQueue = new LinkedTransferQueue<String>();

    public static void main(String[] args) {
        ExecutorService exService = Executors.newFixedThreadPool(2);
        Producer producer = new LinkedTransferQueueDemo().new Producer();
        Consumer consumer = new LinkedTransferQueueDemo().new Consumer();
        exService.execute(producer);
        exService.execute(consumer);
        exService.shutdown();
    }
    class Producer implements Runnable{
        @Override
        public void run() {
            for(int i=0;i<3;i++){
                try {
                    System.out.println("Producer is waiting to transfer...");
                    lnkTransQueue.transfer("A"+i);
                    System.out.println("producer transfered element: A"+i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    class Consumer implements Runnable{
        @Override
        public void run() {
            for(int i=0;i<3;i++){
                try {
                    System.out.println("Consumer is waiting to take element...");
                    String s= lnkTransQueue.take();
                    System.out.println("Consumer received Element: "+s);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

四、demo举例

1. demo: 消费者小于生产者,生产者阻塞 队列.transfer方法

public class LinkedTransferQueueDemo {
    static LinkedTransferQueue<String> lnkTransQueue = new LinkedTransferQueue<String>();

    public static void main(String[] args) {
        ExecutorService exService = Executors.newFixedThreadPool(2);
        Producer producer = new LinkedTransferQueueDemo().new Producer();
        Consumer consumer = new LinkedTransferQueueDemo().new Consumer();
        exService.execute(producer);
        exService.execute(consumer);
        exService.shutdown();

    }
    class Producer implements Runnable{
        @Override
        public void run() {
            for(int i=0;i<3;i++){
                try {
                    System.out.println("Producer is waiting to transfer...");
                    lnkTransQueue.transfer("A"+i);
                    System.out.println("producer transfered element: A"+i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    class Consumer implements Runnable{
        @Override
        public void run() {
            for(int i=0;i<2;i++){
                try {
                    System.out.println("Consumer is waiting to take element...");
                    String s= lnkTransQueue.take();
                    System.out.println("Consumer received Element: "+s);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2. demo:tryTransfer(E e, long timeout, TimeUnit unit) 超时测试

public class TransferQueueDemo2 {
    private static TransferQueue<String> queue = new LinkedTransferQueue<String>();

    public static void main(String[] args) throws Exception {

        new Productor(1).start();
        Thread.sleep(100);
        System.out.println("over.size=" + queue.size());//1
        Thread.sleep(1500);
        System.out.println("over.size=" + queue.size());//0
    }

    static class Productor extends Thread {
        private int id;

        public Productor(int id) {
            this.id = id;
        }

        @Override
        public void run() {
            try {
                String result = "id=" + this.id;
                System.out.println("begin to produce." + result);
                queue.tryTransfer(result, 1, TimeUnit.SECONDS);
                System.out.println("success to produce." + result);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

tryTransfer(E e, long timeout, TimeUnit unit) 测试

  • 第一次还没到指定的时间,元素被插入到队列中了,所有队列长度是1;
  • 第二次指定的时间片耗尽,元素从队列中移除了,所以队列长度是0。

五、参考

Java 7中的TransferQueue
参考URL: http://ifeve.com/java-transfer-queue/
阻塞队列以及应用场景
参考URL: https://www.jianshu.com/p/8503349b27f4
BlockingQueue浅析
参考URL: http://kaimingwan.com/post/java/blockingqueueqian-xi
队列与阻塞队列
参考URL: http://blog.sina.com.cn/s/blog_667ac0360102yk9p.html
java TransferQueue实例详解用法
参考URL: https://www.xz577.com/j/34033.html
阻塞队列LinkedTransferQueue的初窥
参考URL: https://www.jianshu.com/p/6f266a5b3367
Java队列(Queue)了解及使用
参考URL: https://www.jianshu.com/p/7a86c56c632b

已标记关键词 清除标记
相关推荐
©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页
实付 29.90元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值