1. package com.ithema.exam;
   
2. 
   
3. import java.util.concurrent.Callable;
   
4. import java.util.concurrent.ExecutorService;
   
5. import java.util.concurrent.Executors;
   
6. import java.util.concurrent.Future;
   
7. 
   
8. /**
   
9. * 十个线程相加，第一个线程从1加到10，第二个线程从11加到20 ，以此类推，最后再把这10个线程的结果相加，最后输出
   
10. * 分析：每个线程的任务都是有返回值的，因此使用实现Callable接口的线程。
    
11. * 返回值类型是int，而Callable是泛型接口，因此将泛型定义为Integer。
    
12. * 每个线程都通过线程池的ExecutorService对象的submit方法开始运行，并由Future<Integer>对象接收运算结果。
    
13. * 最后将每个Future对象的运算结果取出，相加后打印。
    
14. *
    
15. * @author Administrator
    
16. *
    
17. */
    
18. public class Test1 {
    
19. 
    
20.         public static void main(String[] args) throws Exception {
    
21.                 int sum = 0;
    
22.                 // 建立线程池
    
23.                 ExecutorService es = Executors.newFixedThreadPool(10);
    
24.                 // 运行线程并获取结果
    
25.                 for (int i = 0; i < 10; i++) {
    
26.                         Future<Integer> f = es.submit(new AddThread(i * 10 + 1));
    
27.                         sum = sum + f.get();
    
28.                 }
    
29.                 es.shutdown();
    
30.                 // 打印总结果
    
31.                 System.out.println("sum = " + sum);
    
32.         }
    
33. 
    
34. }
    
35. 
    
36. // 实现Callable<Integer>接口的线程对象
    
37. class AddThread implements Callable<Integer> {
    
38.         private int start;
    
39. 
    
40.         public AddThread(int start) {
    
41.                 this.start = start;
    
42.         }
    
43. 
    
44.         @Override
    
45.         public Integer call() throws Exception {
    
46.                 int sum = 0;
    
47.                 for (int i = start; i < start + 10; i++) {
    
48.                         sum = sum + i;
    
49.                 }
    
50.                 return sum;
    
51.         }
    
52. 
    
53. }

复制代码

谢了 大哥 很实用

很好，学习了

谢谢这段代码 ~

100个赞！！