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