FilesExpand file tree

 master

/

TransferQueue.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

161 lines (154 loc) · 6.09 KB

 master

/

TransferQueue.java

Copy path

Top

File metadata and controls

• Code
• Blame

161 lines (154 loc) · 6.09 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

/*

* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*

*/

/*

*

*

*

*

*

* Written by Doug Lea with assistance from members of JCP JSR-166

* Expert Group and released to the public domain, as explained at

* http://creativecommons.org/publicdomain/zero/1.0/

*/

package java.util.concurrent;

/**

* A {@link BlockingQueue} in which producers may wait for consumers

* to receive elements. A {@code TransferQueue} may be useful for

* example in message passing applications in which producers

* sometimes (using method {@link #transfer}) await receipt of

* elements by consumers invoking {@code take} or {@code poll}, while

* at other times enqueue elements (via method {@code put}) without

* waiting for receipt.

* {@linkplain #tryTransfer(Object) Non-blocking} and

* {@linkplain #tryTransfer(Object,long,TimeUnit) time-out} versions of

* {@code tryTransfer} are also available.

* A {@code TransferQueue} may also be queried, via {@link

* #hasWaitingConsumer}, whether there are any threads waiting for

* items, which is a converse analogy to a {@code peek} operation.

*

* <p>Like other blocking queues, a {@code TransferQueue} may be

* capacity bounded. If so, an attempted transfer operation may

* initially block waiting for available space, and/or subsequently

* block waiting for reception by a consumer. Note that in a queue

* with zero capacity, such as {@link SynchronousQueue}, {@code put}

* and {@code transfer} are effectively synonymous.

*

* <p>This interface is a member of the

* <a href="{@docRoot}/../technotes/guides/collections/index.html">

* Java Collections Framework</a>.

*

* @since 1.7

* @author Doug Lea

* @param <E> the type of elements held in this collection

*/

public interface TransferQueue<E> extends BlockingQueue<E> {

/**

* Transfers the element to a waiting consumer immediately, if possible.

*

* <p>More precisely, transfers the specified element immediately

* if there exists a consumer already waiting to receive it (in

* {@link #take} or timed {@link #poll(long,TimeUnit) poll}),

* otherwise returning {@code false} without enqueuing the element.

*

* @param e the element to transfer

* @return {@code true} if the element was transferred, else

* {@code false}

* @throws ClassCastException if the class of the specified element

* prevents it from being added to this queue

* @throws NullPointerException if the specified element is null

* @throws IllegalArgumentException if some property of the specified

* element prevents it from being added to this queue

*/

boolean tryTransfer(E e);

/**

* Transfers the element to a consumer, waiting if necessary to do so.

*

* <p>More precisely, transfers the specified element immediately

* if there exists a consumer already waiting to receive it (in

* {@link #take} or timed {@link #poll(long,TimeUnit) poll}),

* else waits until the element is received by a consumer.

*

* @param e the element to transfer

* @throws InterruptedException if interrupted while waiting,

* in which case the element is not left enqueued

* @throws ClassCastException if the class of the specified element

* prevents it from being added to this queue

* @throws NullPointerException if the specified element is null

* @throws IllegalArgumentException if some property of the specified

* element prevents it from being added to this queue

*/

void transfer(E e) throws InterruptedException;

/**

* Transfers the element to a consumer if it is possible to do so

* before the timeout elapses.

*

* <p>More precisely, transfers the specified element immediately

* if there exists a consumer already waiting to receive it (in

* {@link #take} or timed {@link #poll(long,TimeUnit) poll}),

* else waits until the element is received by a consumer,

* returning {@code false} if the specified wait time elapses

* before the element can be transferred.

*

* @param e the element to transfer

* @param timeout how long to wait before giving up, in units of

* {@code unit}

* @param unit a {@code TimeUnit} determining how to interpret the

* {@code timeout} parameter

* @return {@code true} if successful, or {@code false} if

* the specified waiting time elapses before completion,

* in which case the element is not left enqueued

* @throws InterruptedException if interrupted while waiting,

* in which case the element is not left enqueued

* @throws ClassCastException if the class of the specified element

* prevents it from being added to this queue

* @throws NullPointerException if the specified element is null

* @throws IllegalArgumentException if some property of the specified

* element prevents it from being added to this queue

*/

boolean tryTransfer(E e, long timeout, TimeUnit unit)

throws InterruptedException;

/**

* Returns {@code true} if there is at least one consumer waiting

* to receive an element via {@link #take} or

* timed {@link #poll(long,TimeUnit) poll}.

* The return value represents a momentary state of affairs.

*

* @return {@code true} if there is at least one waiting consumer

*/

boolean hasWaitingConsumer();

/**

* Returns an estimate of the number of consumers waiting to

* receive elements via {@link #take} or timed

* {@link #poll(long,TimeUnit) poll}. The return value is an

* approximation of a momentary state of affairs, that may be

* inaccurate if consumers have completed or given up waiting.

* The value may be useful for monitoring and heuristics, but

* not for synchronization control. Implementations of this

* method are likely to be noticeably slower than those for

* {@link #hasWaitingConsumer}.

*

* @return the number of consumers waiting to receive elements

*/

int getWaitingConsumerCount();

}