Use of the future interface and callable Interface

1. Import
   Java. util. arraylist;
   
2. Import
   Java. util. List;
   
3. Import
   Java. util. Concurrent. callable;
   
4. Import
   Java. util. Concurrent. executionexception;
   
5. Import
   Java. util. Concurrent. executorservice;
   
6. Import
   Java. util. Concurrent. executors;
   
7. Import
   Java. util. Concurrent. Future;
   
8. Import
   Java. util. Concurrent. futuretask;
   
10. Public
     
    Class
    Concurrentcalculator {
    
12. Private
    Executorservice exec;
    
13. Private
     
    Int
    Cpucorenumber;
    
14. Private
    List <future <long> tasks =
    New
    Arraylist <future <long> ();
    
16. // Internal class
    
    
17. Class
    Sumcalculator
    Implements
    Callable <long> {
    // The part used for calculation in the thread, which is equivalent to the run () method
    
    
18. Private
     
    Int
    [] Numbers;
    
19. Private
     
    Int
    Start;
    
20. Private
     
    Int
    End;
    
22. Public
    Sumcalculator (
    Final
     
    Int
    [] Numbers,
    Int
    Start,
    Int
    End ){
    
23. This
    . Numbers = numbers;
    
24. This
    . Start = start;
    
25. This
    . End = end;
    
26. }
28. Public
    Long call ()
    Throws
    Exception {
    
29. Long sum = 0l;
30. For
    (
    Int
    I = start; I <end; I ++ ){
    
31. Sum + = numbers [I];
32. }
33. Return
    SUM;
    
34. }
35. }
37. Public
    Concurrentcalculator (){
    
38. Cpucorenumber = runtime. getruntime (). availableprocessors ();
39. Exec = executors. newfixedthreadpool (cpucorenumber );
40. }
42. Public
    Long sum (
    Final
     
    Int
    [] Numbers ){
    
43. // Split tasks based on the number of CPU cores, create futuretask, and submit it to executor
    
    
44. For
    (
    Int
    I =
    0
    ; I <cpucorenumber; I ++ ){
    
45. Int
    Increment = numbers. Length/cpucorenumber +
    1
    ;
    
46. Int
    Start = increment * I;
    
47. Int
    End = increment * I + increment;
    
48. If
    (End> numbers. length)
    
49. End = numbers. length;
50. Sumcalculator subcalc = new
    Sumcalculator (numbers, start, end );
    
51. Futuretask <long> task = new
    Futuretask <long> (subcalc );
    // Thread
    
    
52. Tasks. Add (task );
53. If
    (! Exec. isshutdown ()){
    
54. Exec. Submit (task); // execution thread
    
    
55. }
56. }
57. Return
    Getresult ();
    
58. }
60. /**
     
61. * Iterate each task to get the part and return the sum.
     
62. *
     
63. * @ Return
     
64. */
    
    
65. Public
    Long getresult (){
    
66. Long result = 0l;
67. For
    (Future <long> task: tasks ){
    
68. Try
    {
    
69. // Blocking if the calculation is not completed
    
    
70. Long subsum = task. Get (); // obtain the computing result of each thread.
    
    
71. Result + = subsum;
72. } Catch
    (Interruptedexception e ){
    
73. E. printstacktrace ();
74. } Catch
    (Executionexception e ){
    
75. E. printstacktrace ();
76. }
77. }
78. Return
    Result;
    
79. }
81. Public
     
    Void
    Close (){
    
82. Exec. Shutdown ();
83. }
85. Public
     
    Static
     
    Void
    Main (string [] ARGs)
    
86. {
87. Int
    [] Numbers =
    New
     
    Int
    [] {
    1
    ,
    2
    ,
    3
    ,
    4
    ,
    5
    ,
    6
    ,
    7
    ,
    8
    ,
    10
    ,
    11
    };
    
88. Concurrentcalculator calc = new
    Concurrentcalculator ();
    
89. Long sum = Calc. sum (numbers );
90. System. Out. println (SUM );
91. Calc. Close ();
93. }
94. }