Callable接口:

public interface Callable<V> { V call() throws Exception; }
Runnable接口:

public interface Runnable { public abstract void run(); }
相同點:
- 兩者都是接口;(廢話)
- 兩者都可用來編寫多線程程序;
- 兩者都需要調用Thread.start()啟動線程;
不同點:
- 兩者最大的不同點是:實現Callable接口的任務線程能返回執行結果;而實現Runnable接口的任務線程不能返回結果;
- Callable接口的call()方法允許拋出異常;而Runnable接口的run()方法的異常只能在內部消化,不能繼續上拋;
注意點:
- Callable接口支持返回執行結果,此時需要調用FutureTask.get()方法實現,此方法會阻塞主線程直到獲取‘將來’結果;當不調用此方法時,主線程不會阻塞!
Callable工作的Demo:

package com.callable.runnable; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; /** * Created on 2016/5/18. */ public class CallableImpl implements Callable<String> { public CallableImpl(String acceptStr) { this.acceptStr = acceptStr; } private String acceptStr; @Override public String call() throws Exception { // 任務阻塞 1 秒 Thread.sleep(1000); return this.acceptStr + " append some chars and return it!"; } public static void main(String[] args) throws ExecutionException, InterruptedException { Callable<String> callable = new CallableImpl("my callable test!"); FutureTask<String> task = new FutureTask<>(callable); long beginTime = System.currentTimeMillis(); // 創建線程 new Thread(task).start(); // 調用get()阻塞主線程,反之,線程不會阻塞 String result = task.get(); long endTime = System.currentTimeMillis(); System.out.println("hello : " + result); System.out.println("cast : " + (endTime - beginTime) / 1000 + " second!"); } }
測試結果:

hello : my callable test! append some chars and return it! cast : 1 second! Process finished with exit code 0
Runnable工作的Demo:

package com.callable.runnable; /** * Created on 2016/5/18. */ public class RunnableImpl implements Runnable { public RunnableImpl(String acceptStr) { this.acceptStr = acceptStr; } private String acceptStr; @Override public void run() { try { // 線程阻塞 1 秒,此時有異常產生,只能在方法內部消化,無法上拋 Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } // 最終處理結果無法返回 System.out.println("hello : " + this.acceptStr); } public static void main(String[] args) { Runnable runnable = new RunnableImpl("my runable test!"); long beginTime = System.currentTimeMillis(); new Thread(runnable).start(); long endTime = System.currentTimeMillis(); System.out.println("cast : " + (endTime - beginTime) / 1000 + " second!"); } }
測試結果:

cast : 0 second! hello : my runable test! Process finished with exit code 0
寫此篇的原因是一次面試中問到Callable與Runnable的區別,當時用的多的是Runnable,而Callable使用很少!
比較了兩者后(網上查了不少),發現Callable在很多特殊的場景下還是很有用的!最后留點抄的代碼,加深對Callable的認識!

package com.inte.fork; /** * Created on 2016/4/20. */ import java.util.*; import java.util.concurrent.*; import static java.util.Arrays.asList; public class Sums { static class Sum implements Callable<Long> { private final long from; private final long to; Sum(long from, long to) { this.from = from; this.to = to; } @Override public Long call() { long acc = 0; for (long i = from; i <= to; i++) { acc = acc + i; } System.out.println(Thread.currentThread().getName() + " : " + acc); return acc; } } public static void main(String[] args) throws Exception { ExecutorService executor = Executors.newFixedThreadPool(3); List<Future<Long>> results = executor.invokeAll(asList( new Sum(0, 10), new Sum(0, 1_000), new Sum(0, 1_000_000) )); executor.shutdown(); for (Future<Long> result : results) { System.out.println(result.get()); } } }