【Java并发编程】4、JDK7中TransferQueue的使用以及TransferQueue与SynchronousQueue的差别

转自：http://blog.csdn.net/aitangyong/article/details/46472643

JDK7对JDK5中的J.U.C并发工具进行了增强，其中之一就是新增了TransferQueue。Java并发相关的JSR规范，可以查看Doug Lea维护的blog。现在简单介绍下这个类的使用方式。

1. public interface TransferQueue<E> extends BlockingQueue<E>
2. {
3. /**
4. * Transfers the element to a waiting consumer immediately, if possible.
5. *
6. * <p>More precisely, transfers the specified element immediately
7. * if there exists a consumer already waiting to receive it (in
8. * {@link #take} or timed {@link #poll(long,TimeUnit) poll}),
9. * otherwise returning {@code false} without enqueuing the element.
10. *
11. * @param e the element to transfer
12. * @return {@code true} if the element was transferred, else
13. *         {@code false}
14. * @throws ClassCastException if the class of the specified element
15. *         prevents it from being added to this queue
16. * @throws NullPointerException if the specified element is null
17. * @throws IllegalArgumentException if some property of the specified
18. *         element prevents it from being added to this queue
19. */
20. boolean tryTransfer(E e);
21. /**
22. * Transfers the element to a consumer, waiting if necessary to do so.
23. *
24. * <p>More precisely, transfers the specified element immediately
25. * if there exists a consumer already waiting to receive it (in
26. * {@link #take} or timed {@link #poll(long,TimeUnit) poll}),
27. * else waits until the element is received by a consumer.
28. *
29. * @param e the element to transfer
30. * @throws InterruptedException if interrupted while waiting,
31. *         in which case the element is not left enqueued
32. * @throws ClassCastException if the class of the specified element
33. *         prevents it from being added to this queue
34. * @throws NullPointerException if the specified element is null
35. * @throws IllegalArgumentException if some property of the specified
36. *         element prevents it from being added to this queue
37. */
38. void transfer(E e) throws InterruptedException;
39. /**
40. * Transfers the element to a consumer if it is possible to do so
41. * before the timeout elapses.
42. *
43. * <p>More precisely, transfers the specified element immediately
44. * if there exists a consumer already waiting to receive it (in
45. * {@link #take} or timed {@link #poll(long,TimeUnit) poll}),
46. * else waits until the element is received by a consumer,
47. * returning {@code false} if the specified wait time elapses
48. * before the element can be transferred.
49. *
50. * @param e the element to transfer
51. * @param timeout how long to wait before giving up, in units of
52. *        {@code unit}
53. * @param unit a {@code TimeUnit} determining how to interpret the
54. *        {@code timeout} parameter
55. * @return {@code true} if successful, or {@code false} if
56. *         the specified waiting time elapses before completion,
57. *         in which case the element is not left enqueued
58. * @throws InterruptedException if interrupted while waiting,
59. *         in which case the element is not left enqueued
60. * @throws ClassCastException if the class of the specified element
61. *         prevents it from being added to this queue
62. * @throws NullPointerException if the specified element is null
63. * @throws IllegalArgumentException if some property of the specified
64. *         element prevents it from being added to this queue
65. */
66. boolean tryTransfer(E e, long timeout, TimeUnit unit)
67. throws InterruptedException;
68. /**
69. * Returns {@code true} if there is at least one consumer waiting
70. * to receive an element via {@link #take} or
71. * timed {@link #poll(long,TimeUnit) poll}.
72. * The return value represents a momentary state of affairs.
73. *
74. * @return {@code true} if there is at least one waiting consumer
75. */
76. boolean hasWaitingConsumer();
77. /**
78. * Returns an estimate of the number of consumers waiting to
79. * receive elements via {@link #take} or timed
80. * {@link #poll(long,TimeUnit) poll}.  The return value is an
81. * approximation of a momentary state of affairs, that may be
82. * inaccurate if consumers have completed or given up waiting.
83. * The value may be useful for monitoring and heuristics, but
84. * not for synchronization control.  Implementations of this
85. * method are likely to be noticeably slower than those for
86. * {@link #hasWaitingConsumer}.
87. *
88. * @return the number of consumers waiting to receive elements
89. */
90. int getWaitingConsumerCount();
91. }

可以看到TransferQueue同时也是一个阻塞队列，它具备阻塞队列的所有特性，主要介绍下上面5个新增API的作用。

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

1. public class TransferQueueDemo {
2. private static TransferQueue<String> queue = new LinkedTransferQueue<String>();
3. public static void main(String[] args) throws Exception {
4. new Productor(1).start();
5. Thread.sleep(100);
6. System.out.println("over.size=" + queue.size());
7. }
8. static class Productor extends Thread {
9. private int id;
10. public Productor(int id) {
11. this.id = id;
12. }
13. @Override
14. public void run() {
15. try {
16. String result = "id=" + this.id;
17. System.out.println("begin to produce." + result);
18. queue.transfer(result);
19. System.out.println("success to produce." + result);
20. } catch (InterruptedException e) {
21. e.printStackTrace();
22. }
23. }
24. }
25. }

可以看到生产者线程会阻塞，因为调用transfer()的时候并没有消费者在等待获取数据。队列长度变成了1，说明元素e没有移交成功的时候，会被插入到阻塞队列的尾部。

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

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

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

1. public class TransferQueueDemo {
2. private static TransferQueue<String> queue = new LinkedTransferQueue<String>();
3. public static void main(String[] args) throws Exception {
4. new Productor(1).start();
5. Thread.sleep(100);
6. System.out.println("over.size=" + queue.size());//1
7. Thread.sleep(1500);
8. System.out.println("over.size=" + queue.size());//0
9. }
10. static class Productor extends Thread {
11. private int id;
12. public Productor(int id) {
13. this.id = id;
14. }
15. @Override
16. public void run() {
17. try {
18. String result = "id=" + this.id;
19. System.out.println("begin to produce." + result);
20. queue.tryTransfer(result, 1, TimeUnit.SECONDS);
21. System.out.println("success to produce." + result);
22. } catch (Exception e) {
23. e.printStackTrace();
24. }
25. }
26. }
27. }

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

这篇文章中讲了SynchronousQueue的使用方式，可以看到TransferQueue也具有SynchronousQueue的所有功能，但是TransferQueue的功能更强大。这篇文章中提到了这2个API的区别：

1. TransferQueue is more generic and useful than SynchronousQueue however as it allows you to flexibly decide whether to use normal BlockingQueue
2. semantics or a guaranteed hand-off. In the case where items are already in the queue, calling transfer will guarantee that all existing queue
3. items will be processed before the transferred item.
4. SynchronousQueue implementation uses dual queues (for waiting producers and waiting consumers) and protects both queues with a single lock. The
5. LinkedTransferQueue implementation uses CAS operations to form a nonblocking implementation and that is at the heart of avoiding serialization
6. bottlenecks.