FilesExpand file tree

 master

/

CompletionService.java

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

124 lines (117 loc) · 4.07 KB

 master

/

CompletionService.java

Copy path

Top

File metadata and controls

• Code
• Blame

124 lines (117 loc) · 4.07 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

/*

* 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 service that decouples the production of new asynchronous tasks

* from the consumption of the results of completed tasks. Producers

* {@code submit} tasks for execution. Consumers {@code take}

* completed tasks and process their results in the order they

* complete. A {@code CompletionService} can for example be used to

* manage asynchronous I/O, in which tasks that perform reads are

* submitted in one part of a program or system, and then acted upon

* in a different part of the program when the reads complete,

* possibly in a different order than they were requested.

*

* <p>Typically, a {@code CompletionService} relies on a separate

* {@link Executor} to actually execute the tasks, in which case the

* {@code CompletionService} only manages an internal completion

* queue. The {@link ExecutorCompletionService} class provides an

* implementation of this approach.

*

* <p>Memory consistency effects: Actions in a thread prior to

* submitting a task to a {@code CompletionService}

* <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>

* actions taken by that task, which in turn <i>happen-before</i>

* actions following a successful return from the corresponding {@code take()}.

*/

public interface CompletionService<V> {

/**

* Submits a value-returning task for execution and returns a Future

* representing the pending results of the task. Upon completion,

* this task may be taken or polled.

*

* @param task the task to submit

* @return a Future representing pending completion of the task

* @throws RejectedExecutionException if the task cannot be

* scheduled for execution

* @throws NullPointerException if the task is null

*/

Future<V> submit(Callable<V> task);

/**

* Submits a Runnable task for execution and returns a Future

* representing that task. Upon completion, this task may be

* taken or polled.

*

* @param task the task to submit

* @param result the result to return upon successful completion

* @return a Future representing pending completion of the task,

* and whose {@code get()} method will return the given

* result value upon completion

* @throws RejectedExecutionException if the task cannot be

* scheduled for execution

* @throws NullPointerException if the task is null

*/

Future<V> submit(Runnable task, V result);

/**

* Retrieves and removes the Future representing the next

* completed task, waiting if none are yet present.

*

* @return the Future representing the next completed task

* @throws InterruptedException if interrupted while waiting

*/

Future<V> take() throws InterruptedException;

/**

* Retrieves and removes the Future representing the next

* completed task, or {@code null} if none are present.

*

* @return the Future representing the next completed task, or

* {@code null} if none are present

*/

Future<V> poll();

/**

* Retrieves and removes the Future representing the next

* completed task, waiting if necessary up to the specified wait

* time if none are yet present.

*

* @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 the Future representing the next completed task or

* {@code null} if the specified waiting time elapses

* before one is present

* @throws InterruptedException if interrupted while waiting

*/

Future<V> poll(long timeout, TimeUnit unit) throws InterruptedException;

}