1 package ThreadTest;
 2 
 3 import java.util.concurrent.Callable;
 4 import java.util.concurrent.ExecutionException;
 5 import java.util.concurrent.FutureTask;
 6 
 7 public class CallableTest implements Callable {
 8     @Override
 9     public Object call() throws Exception {
10         int sum=0;
 
11         for ( int i = 0; i <=100; i++) {
12             if (i % 2 == 0) {
13                 sum=sum+i;
14                 System.out.println(Thread.currentThread().getName() + ":" + i);
15             }
16         }
17         return sum;
18     }
19 }
20 
21 
22 class Tse{
23     public static void
 
 main(String[] args) {
24         //3：建立callable介面實現類的物件
25         CallableTest callableTest=new CallableTest();
26         //4：將此實現類的物件作為形參傳入FutureTask的構造器中，建立FutureTask的物件
27         FutureTask futureTask=new FutureTask(callableTest);
28         //5: 將FutureTask的物件作為形參傳入thread類的構造器中建立thread物件
29         Thread thread=new
 
 Thread(futureTask);
30         thread.setName("執行緒1:");
31         thread.start();
32         //6:獲取callable中的返回值，get返回值即為FutureTask實現類重寫的call()返回值，
33         try {
34            Object sum= futureTask.get();
35             System.out.println("總和為："+sum);
36         } catch (InterruptedException e) {
37             e.printStackTrace();
38         } catch (ExecutionException e) {
39             e.printStackTrace();
40         }
41     }
42 }

對於實現Callable介面的方式與runnable介面的異同在於

1：重寫實現類的run方法，pulic Object void run（）{return sum} 可以有返回值

2：建立實現類的物件

3：將實現類的物件作為形參傳入FutureTask的構造器中，建立FutureTask物件

4：將FutureTask的物件作為形參傳入Thread類的構造器中，建立Thread類物件

5：Thread物件.start(),此時可以通過 Object sum=futuretask物件.get()得到返回值

 1 package ThreadTest;
 2 /**
 3  * 建立執行緒的方法4：使用執行緒池
 4  */
 5 
 6 import java.util.concurrent.*;
 7 class TT implements Runnable{
 8     @Override
 9     public void run() {
10         int sum = 0;
11         for (int i = 0; i <= 100; i++) {
12             if (i % 2 == 0) {
13                 System.out.println(i);
14             }
15         }
16     }
17 
18 }
19 
20 class TT1 implements Runnable{
21     @Override
22     public void run() {
23         int sum = 0;
24         for (int i = 0; i <= 100; i++) {
25             if (i % 2 != 0) {
26                 System.out.println(i);
27             }
28         }
29     }
30 
31 }
32 public class ThreadPool {
33     public static void main(String[] args) {
34         //1:提供指定執行緒數量的執行緒池
35         ExecutorService service = Executors.newFixedThreadPool(10);
36         //2:執行指定執行緒的操作，需要提供實現runnable介面實現類的物件
37         service.execute(new TT());//適用於runnable
38         service.execute(new TT1());//適用於runnable
39         //service.submit(); //適用於callable
40         //關閉執行緒池
41         service.shutdown();
42     }
43 }

對於執行緒池主要的步驟：

1：提供執行緒池：ExecutorService service=Executors.newFixdThreadPool(執行緒池數量)；

2：service.execute(new 實現類的物件());

3：service.shoudown 關閉執行緒池