Java Thread completionservice Batch processing task

What if you submitted a batch task to executor and want to get the results after they are done?

To do this, you can save the future associated with each task, and then constantly invoke a get with a timeout of zero to verify that the future is complete. This can be done, but it is rather tedious. Fortunately, there is a better way: to complete the service (completion services).

Completionservice integrates the functions of executor and blockingqueue.

You can submit the callable task to it for execution, and then use the take and poll methods that are similar to the queue to get this result when the results are fully available, like a packaged future. Executorcompletionservice is a class that implements the Completionservice interface and delegates the compute task to a executor.

The implementation of Executorcompletionservice is quite straightforward. It creates a blockingqueue in the constructor and uses it to keep the finished result. The Done method in Futuretask is called when the calculation is complete.

When a task is submitted, the task is first packaged as a queueingfuture, which is a subclass of Futuretask, then overwrite the done method, placing the result in Blockingqueue, and the take and poll methods delegated to the Blockingqueue, it blocks when the results are not available.

See Demo directly:

Package Javademo;

Import Java.util.Random;

Import Java.util.concurrent.BlockingQueue;

Import java.util.concurrent.Callable;

Import Java.util.concurrent.CompletionService;

Import java.util.concurrent.ExecutionException;

Import Java.util.concurrent.ExecutorCompletionService;

Import Java.util.concurrent.ExecutorService;

Import java.util.concurrent.Executors;

Import Java.util.concurrent.Future;

Import Java.util.concurrent.LinkedBlockingQueue;

/***

* Two clock way out thread run result

* @author Think

*

*/

public class Completionservicetest {

public static void Main (string[] args) throws Exception {

Completionservicetest CST = new Completionservicetest ();

Cst.count1 ();

Cst.count2 ();

}

/***

* Use the blocking container to save the results of each executor processing, and then perform the uniform processing later

* @throws Exception

*/

public void Count1 () throws exception{

Executorservice exec = Executors.newcachedthreadpool ();

blockingqueue<future<integer>> queue = new linkedblockingqueue<future<integer>> ();

for (int i=0; i<10; i++) {

Future<integer> Future =exec.submit (Gettask ());

Queue.add (future);

}

int sum = 0;

int queuesize = Queue.size ();

for (int i=0; i<queuesize; i++) {

Sum + = Queue.take (). get ();

}

System.out.println ("total:" +sum);

Exec.shutdown ();

}

/***

* Use Completionservice (complete service) to maintain the results of executor processing

* @throws interruptedexception

* @throws executionexception

*/

public void Count2 () throws Interruptedexception, executionexception{

Executorservice exec = Executors.newcachedthreadpool ();

completionservice<integer> Execcomp = new executorcompletionservice<integer> (exec);

for (int i=0; i<10; i++) {

Execcomp.submit (Gettask ());

}

int sum = 0;

for (int i=0; i<10; i++) {

Retrieves and removes the future that represents the next completed task, and waits if no such task exists at this time.

future<integer> future = Execcomp.take ();

Sum + = Future.get ();

}

System.out.println ("total:" +sum);

Exec.shutdown ();

}

/**

* Get a job

* @return Callable

*/

Public callable<integer> Gettask () {

Final random rand = new Random ();

callable<integer> task = new callable<integer> () {

@Override

Public Integer Call () throws Exception {

int i = Rand.nextint (10);

Int J = Rand.nextint (10);

int sum = I*J;

System.out.print (sum+ "\ t");

return sum;

}

};

return task;

}

}

2. import java.util.Random;
4. import java.util.concurrent.BlockingQueue;
6. import java.util.concurrent.Callable;
8. import Java.util.concurrent.CompletionService;
10. import java.util.concurrent.ExecutionException;
12. import Java.util.concurrent.ExecutorCompletionService;
14. import Java.util.concurrent.ExecutorService;
16. import java.util.concurrent.Executors;
18. import java.util.concurrent.Future;
20. import java.util.concurrent.LinkedBlockingQueue;
24. Public class Test17 {
26. Public Static void Main (string[] args) throws Exception {
28. Test17 t = new Test17 ();
30. T.count1 ();
32. T.count2 ();
34. }
36. //Use a blocking container to save the results of each executor process, and then perform a unified process later
38. Public void count1 () throws exception{
40. Executorservice exec = Executors.newcachedthreadpool ();
42. blockingqueue<future<integer>> queue = new linkedblockingqueue<future<integer>> () ;
44. for (int i=0; i<; i++) {
46. Future<integer> Future =exec.submit (Gettask ());
48. Queue.add (future);
50. }
52. int sum = 0;
54. int queuesize = queue.size ();
56. for (int i=0; i<queuesize; i++) {
58. Sum + = Queue.take (). get ();
60. }
62. System.out.println ("total:"+sum);
64. Exec.shutdown ();
66. }
68. //Use Completionservice (complete service) to maintain the results of executor processing
70. Public void Count2 () throws Interruptedexception, executionexception{
72. Executorservice exec = Executors.newcachedthreadpool ();
74. completionservice<integer> Execcomp = new executorcompletionservice<integer> (exec);
76. for (int i=0; i<; i++) {
78. Execcomp.submit (Gettask ());
80. }
82. int sum = 0;
84. for (int i=0; i<; i++) {
86. //Retrieve and remove the future that represents the next completed task, and wait if no such task exists at this time.
88. future<integer> future = Execcomp.take ();
90. Sum + = Future.get ();
92. }
94. System.out.println ("total:"+sum);
96. Exec.shutdown ();
98. }
100. //Get a task
102. Public Callable<integer> Gettask () {
104. Final Random rand = new random ();
106. callable<integer> task = new callable<integer> () {
108. @Override
110. Public Integer call () throws Exception {
112. int i = rand.nextint (ten);
114. int j = rand.nextint (ten);
116. int sum = i*j;
118. System.out.print (sum+"\ t");
120. return sum;
122. }
124. };
126. return task;
128. }
130. /**
132. * Execution Result:
134. 6 6 14 40 40 0 4 7 0 0 Total: 106
136. 12 6 12 54 81 18 14 35 45 35 total: 312
138.      */
140. }

Java Thread completionservice Batch processing task