Multithreading (ii)

See Write a more detailed piece of description InvokeAll and Invokeany method, modify, and take to explain the problem.

Executorservice is a core interface provided by the JDK Concurrency Toolkit, which is equivalent to a thread pool that provides methods for performing tasks and managing the lifecycle. Most of the APIs in the Executorservice interface are relatively easy to use, this article mainly introduces the characteristics and use of the InvokeAll and Invokeany methods. Let's start with a few task classes: a time-consuming task, an exception task, and a short-term task. They will be used in the next Test code.

2. package tasks;
6. Import java.util.concurrent.Callable;
8. Import Java.util.concurrent.TimeUnit;
12. public class Sleepsecondscallable implements Callable<string>
14. {
16. private String name;
20. private int seconds;
24. Public sleepsecondscallable (String name, int seconds)
26. {
28. THIS.name = name;
30. This.seconds = seconds;
32. }
36. Public String Call () throws Exception
38. {
40. SYSTEM.OUT.PRINTLN (name + ", begin to execute");
44. Try
46. {
48. TimeUnit.SECONDS.sleep (SECONDS);
50. } catch (Interruptedexception e)
52. {
54. SYSTEM.OUT.PRINTLN (name + "was disturbed during sleeping.");
56. E.printstacktrace ();
58. Return name + "_sleepsecondscallable_failed";
60. }
64. SYSTEM.OUT.PRINTLN (name + ", success to execute");
68. Return name + "_sleepsecondscallable_succes";
70. }
74. }

This is a time-consuming task that simulates through sleep, which is an interruptible/terminated task that responds to an interrupt request.

[Java] view plaincopy

2. package tasks;
6. Import java.util.concurrent.Callable;
10. public class Exceptioncallable implements Callable<string>
12. {
16. Private String name = NULL;
20. Public exceptioncallable ()
22. {
26. }
30. Public exceptioncallable (String name)
32. {
34. THIS.name = name;
36. }
40. @Override
42. Public String Call () throws Exception
44. {
46. SYSTEM.OUT.PRINTLN ("Begin to Exceptioncallable.");
50. System.out.println (Name.length ());
54. System.out.println ("End to Exceptioncallable.");
58. return name;
60. }
64. }

This is a task that may throw a null pointer exception during execution.

[Java] view plaincopy

2. package tasks;
6. Import Java.util.Random;
8. Import java.util.concurrent.Callable;
12. public class Randomtencharstask implements Callable<string>
14. {
18. @Override
20. Public String Call () throws Exception
22. {
24. SYSTEM.OUT.PRINTLN ("Randomtencharstask begin to execute ...");
28. StringBuffer content = new StringBuffer ();
32. String base = "abcdefghijklmnopqrstuvwxyz0123456789";
36. Random random = new random ();
40. for (int i = 0; i <; i++)
42. {
44. int number = Random.nextint (Base.length ());
46. Content.append (Base.charat (number));
48. }
52. System.out.println ("Randomtencharstask complete.result=" + content);
54. return content.tostring ();
56. }
60. }

This is a normal short-term task that produces a string consisting of 10 random characters. 1. Test Invokeany ()

In the first case, submit 2 time-consuming tasks to the thread pool sleepsecondscallable

[Java] view plaincopy

1. /**
2. * Commits a task collection that terminates other unfinished tasks once a task is completed normally (without throwing an exception)
3. /
4. public static void Invokean Y1 () throws exception  
5. {  
6.     executorservice executorservice = Executors.newfixedthreadpool (3);  
8.     list<callable<string >> tasks = new arraylist<callable<string>> ();  
10.     Tas Ks.add (New sleepsecondscallable ("T1", 2));  
11.     tasks.add (new Sleepsecondscallable ("T2", 1));  
13.     String result = EXECUTORSERVICE.INV Okeany (Tasks);  
15.     System.out.println ("result=" + result);   
17.     executorservice.shutdown ();  
18. } 

The result of the execution of the program is to return the execution result of the T2 thread t2_sleepsecondscallable_succes, while T1 throws Java.lang.InterruptedException:sleep interrupted.

the thread pool terminates other unfinished tasks once a task is completed normally (no exception is thrown during execution) .

In the second case, submit 3 exception tasks to the thread pool exceptioncallable

[Java] view plaincopy

2. /**
4. * No 1 normally completed tasks, Invokeany () method throws Executionexception, encapsulates the exception of elements in the task
6. *
8. */
10. public static void InvokeAny2 () throws Exception
12. {
14. Executorservice Executorservice = Executors.newfixedthreadpool (3);
18. list<callable<string>> tasks = new arraylist<callable<string>> ();
22. Tasks.add (New exceptioncallable ());
24. Tasks.add (New exceptioncallable ());
26. Tasks.add (New exceptioncallable ());
30. String result = Executorservice.invokeany (tasks);
34. System.out.println ("result=" + result);
38. Executorservice.shutdown ();
40. }

Program execution result is: Call Invokeany () error java.util.concurrent.ExecutionException:java.lang.NullPointerException.

In other words: if there are no 1 tasks that are normally completed in the list of tasks submitted, then calling Invokeany will throw an exception, and it doesn't matter what task is thrown.

Third case: Commit 3 unusual tasks before committing 1 normal time-consuming tasks

[Java] view plaincopy

2. /**
4. * There are unusual tasks, normal tasks, Invokeany () will not throw an exception, return to the task of the first normal completion
6. */
8. public static void InvokeAny3 () throws Exception
10. {
12. Executorservice Executorservice = Executors.newfixedthreadpool (3);
16. list<callable<string>> tasks = new arraylist<callable<string>> ();
20. Tasks.add (New exceptioncallable ());
22. Tasks.add (New exceptioncallable ());
24. Tasks.add (New exceptioncallable ());
26. Tasks.add (New exceptioncallable ());
30. Tasks.add (New sleepsecondscallable ("T1", 2));
34. String result = Executorservice.invokeany (tasks);
38. System.out.println ("result=" + result);
40. Executorservice.shutdown ();
42. }

The result of the program execution is: No exception is thrown and the return result of the T2 task is printed out. Thatis, Invokeany () is independent of the order in which the tasks are submitted, but returns the task that was performed as early as normal .

In the fourth case, the test uses a limited-time version of the Invokeany (), the main function and the unlimited version of the difference is not small

[Java] view plaincopy

2. /**
4. * Not yet until timeout, so the task has been abnormally completed, thrown executionexception<br>
6. * If the time expires before full, there is no unfinished task, throw TimeoutException
8. */
10. public static void Invokeanytimeout () throws Exception
12. {
14. Executorservice Executorservice = Executors.newfixedthreadpool (3);
18. list<callable<string>> tasks = new arraylist<callable<string>> ();
22. Tasks.add (New exceptioncallable ());
24. Tasks.add (New exceptioncallable ());
26. Tasks.add (New exceptioncallable ());
28. Tasks.add (New exceptioncallable ());
32. String result = Executorservice.invokeany (tasks, 2, timeunit.seconds);
36. System.out.println ("result=" + result);
40. Executorservice.shutdown ();
42. }

The result of the program execution is: Throw executionexception. This is actually very reasonable, but also very well understood. If all the tasks are terminated abnormally before the time-out, then there is no need to wait, and if after a timeout there are still tasks running or waiting to run, then TimeoutException will be thrown.

Finally, let's look at the Executorservice.invokeany method signature and comment in the JDK source code.

[Java] view plaincopy

2. /**
4. * Executes the given tasks, returning the result
6. * of one that has completed successfully (i.e., without throwing
8. * An exception), if any do. Upon normal or exceptional return,
10. * Tasks that has not completed is cancelled.
12. * The results of this method is undefined if the given
14. * Collection is modified while the this operation are in progress.
16. *
18. * @param tasks The collection of tasks
20. * @return The result returned by one of the tasks
22. * @throws interruptedexception if interrupted while waiting
24. * @throws NullPointerException if tasks or any of its elements
26. * Is <tt>null</tt>
28. * @throws IllegalArgumentException if tasks is empty
30. * @throws executionexception If no task successfully completes
32. * @throws Rejectedexecutionexception If tasks cannot be scheduled
34. * For execution
36. */
38. <T> T invokeany (collection<? extends callable<t>> tasks)
40. Throws Interruptedexception, Executionexception;

Consistent with our test results, Invokeany () returns the immediate result of the task that was first completed (without throwing exception); The thread pool terminates running or waiting to run once a task is completed properly or an exception is called has not completed is cancelled) task. 2. Test InvokeAll () This method is relatively well understood, which is to perform all tasks in the Task list and return the futue corresponding to each task. That is, tasks do not interact with each other, and the future can be used to track the execution of each task, such as whether it is canceled, normal, or abnormal, mainly using the API provided by the future class.

[Java] view plaincopy

2. public static void Testinvokeall () throws Exception
4. {
6. Executorservice Executorservice = Executors.newfixedthreadpool (5);
10. list<callable<string>> tasks = new arraylist<callable<string>> ();
12. Tasks.add (New sleepsecondscallable ("T1", 2));
14. Tasks.add (New sleepsecondscallable ("T2", 2));
16. Tasks.add (New Randomtencharstask ());
18. Tasks.add (New exceptioncallable ());
22. The thread that called the method blocks until all tasks are completed (normal completion/exception exit)
24. list<future<string>> results = Executorservice.invokeall (tasks);
28. All tasks in the task list are completed before the statement is executed
30. System.out.println ("Wait for the result." + results.size ());
34. Executorservice.shutdown ();
38. for (future<string> f:results)
40. {
42. Iscanceled=false,isdone=true
44. System.out.println ("iscanceled=" + f.iscancelled () + ", isdone="
46. + F.isdone ());
50. Exceptioncallable mission will be reported executionexception
52. System.out.println ("task result=" + f.get ());
54. }
56. }

The execution results and some conclusions of the program have been written directly in the code comments. InvokeAll is a blocking method that waits for all tasks in the task list to complete. Future.isdone () always returns true regardless of whether the task is completed normally or terminated abnormally. The future.iscanceled () can be used to determine whether a task is canceled during execution. You can get the return result of a task through future.get (), or the exception that the task throws in execution.

In the second case, test the time-limited version of InvokeAll (COLLECTION<? extends callable<t>> tasks,long timeout, timeunit unit)

[Java] view plaincopy

2. /**
4. * Can be judged by future.iscanceled () whether the task is canceled or completed (normal/abnormal) <br>
6. * Future.isdone () always returns True, no use for callers of InvokeAll ()
8. */
10. public static void Testinvokealltimeout () throws Exception
12. {
14. Executorservice Executorservice = Executors.newfixedthreadpool (5);
18. list<callable<string>> tasks = new arraylist<callable<string>> ();
20. Tasks.add (New sleepsecondscallable ("T1", 2));
22. Tasks.add (New sleepsecondscallable ("T2", 2));
24. Tasks.add (New sleepsecondscallable ("T3", 3));
26. Tasks.add (New Randomtencharstask ());
30. list<future<string>> results = Executorservice.invokeall (tasks, 1,
32. Timeunit.seconds);
36. System.out.println ("Wait for the result." + results.size ());
40. for (future<string> f:results)
42. {
44. System.out.println ("iscanceled=" + f.iscancelled () + ", isdone="
46. + F.isdone ());
48. }
52. Executorservice.shutdown ();
56. }

The execution results are:

Wait for the Result.4
Iscanceled=true,isdone=true
Iscanceled=true,isdone=true
Iscanceled=true,isdone=true
Iscanceled=false,isdone=true

This means that a given time-out expires, a task that has not yet been completed is canceled, that is, future.iscancelled () returns True, and Future.iscancelled () returns false before the timeout period, whether it is a normal or abnormally terminated task.
In the third case, the thread is interrupted before the test waits for invokeall execution to complete.

[Java] view plaincopy

2. /**
4. * If the thread is interrupted while waiting for InvokeAll () execution to complete, it throws interruptedexception<br>
6. * This time the thread pool terminates tasks that are not completed, mainly to reduce the waste of resources.
8. */
10. public static void Testinvokeallwheninterrupt () throws Exception
12. {
14. Final Executorservice Executorservice = Executors.newfixedthreadpool (5);
18. Thread that calls InvokeAll
20. Thread invokeallthread = new Thread () {
24. @Override
26. public void Run ()
28. {
30. list<callable<string>> tasks = new arraylist<callable<string>> ();
32. Tasks.add (New sleepsecondscallable ("T1", 2));
34. Tasks.add (New sleepsecondscallable ("T2", 2));
36. Tasks.add (New Randomtencharstask ());
40. The calling thread blocks until all tasks are completed (normal completion/exception exit)
42. Try
44. {
46. list<future<string>> results = Executorservice
48. . InvokeAll (tasks);
50. System.out.println ("Wait for the result." + results.size ());
52. } catch (Interruptedexception e)
54. {
56. System.out
58. . println ("I was wait,but my thread was interrupted.");
60. E.printstacktrace ();
62. }
66. }
68. };
72. Invokeallthread.start ();
76. Thread.Sleep (200);
80. Invokeallthread.interrupt ();
84. Executorservice.shutdown ();
88. }

The invokeallthread thread called Executorservice.invokeall () and Invokeallthread was interrupted by another thread while waiting for the task to complete. This time,

Executorservice.invokeall () throws Java.lang.InterruptedException, task T1 and T2 are terminated and thrown java.lang.InterruptedException:sleep Interrupted.

This means that once the Executorservice.invokeall () method produces an exception, a task that has not yet been completed in the thread pool is canceled.

Multithreading (ii)