亚洲国产中文在线观看,亚洲视频精品在线,久久国内精品

Java中的Runable,Callable,Future,FutureTask,ExecutorService,Excetor,Excutors,ThreadPoolExcetor在這里對這些關鍵詞，以及它們的用法做一個總結。

首先將它們分個類：

Runable,Callable
Future,FutureTask
ExecutorService,Excetor,Excutors,ThreadPoolExcetor

1. 關于Ranable和Callable

首先Java中創建線程的方法有三種：

繼承Thread類，覆蓋run方法
實現Runable接口，實現run方法
實現Callable接口，實現run方法

三種實現的優缺點：

繼承Thread，單繼承的緣故，不能再繼承其他類，獲取當前線程this

實現Runable接口，沒有返回值，獲取當前線程Thread.currentThread()

實現Callable接口，可通過Future.get()獲取返回值，獲取當前線程 Thread.currentThread()

繼承Thread，兩個步驟：

									class DemoThread extends Thread {

									  @Override

									  public void run() {

									    super.run();

									    // Perform time-consuming operation...

									  }

									}

									DemoThread t = new DemoThread();

									t.start();

繼承Thread類，覆蓋run()方法。
創建線程對象并用start()方法啟動線程。

實現Runable，一般使用如下：

									new Thread(new Runnable() {

									  @Override

									  public void run() {

									    // do something

									  }

									}).start();

為了簡單。

以上兩種方式獲取線程執行的結果相當麻煩，不能直接獲取。JDK1.5增加了 Callable, Callable 的 call() 方法可以返回值和拋出異常。Callable 可以返回裝載有計算結果的 Future 對象。
Callable的源碼：

									public interface Callable<V> {

									  V call() throws Exception;

									}

Callable的基本使用方法：

									FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {

									  @Override

									  public Integer call() throws Exception {

									    // do something

									    return null;

									  }

									});

									Thread thread = new Thread(futureTask);

									thread.start();

									Integer result = futureTask.get();

運行 Callable 任務可以拿到一個 Future 對象，通過Future的get()方法拿到線程執行的返回值。那么...Future，

FutureTask區別是什么，怎么使用？

->next()

2. 關于Future和FutureTask

為了獲取線程的執行結果，引入了Future的FutureTask，那么他們是什么關系，如何使用？

Future類位于java.util.concurrent包下，它是一個接口：

									public interface Future<V> {

									  boolean cancel(boolean mayInterruptIfRunning);

									  boolean isCancelled();

									  boolean isDone();

									  V get() throws InterruptedException, ExecutionException;

									  V get(long timeout, TimeUnit unit)

									    throws InterruptedException, ExecutionException, TimeoutException;

									}

Future 定義了5個方法：

1）boolean cancel(boolean mayInterruptIfRunning)：試圖取消對此任務的執行。如果任務已完成、或已取消，或者由于某些其他原因而無法取消，則此嘗試將失敗。當調用 cancel() 時，如果調用成功，而此任務尚未啟動，則此任務將永不運行。如果任務已經啟動，則 mayInterruptIfRunning 參數確定是否應該以試圖停止任務的方式來中斷執行此任務的線程。此方法返回后，對 isDone() 的后續調用將始終返回 true。如果此方法返回 true，則對 isCancelled() 的后續調用將始終返回 true。

2）boolean isCancelled()：如果在任務正常完成前將其取消，則返回 true。

3）boolean isDone()：如果任務已完成，則返回 true。可能由于正常終止、異常或取消而完成，在所有這些情況中，此方法都將返回 true。

4）V get()throws InterruptedException,ExecutionException：如有必要，等待計算完成，然后獲取其結果。

5）V get(long timeout,TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException：如有必要，最多等待為使計算完成所給定的時間之后，獲取其結果（如果結果可用）。

總的來說Future提供了三種功能：

判斷任務是否完成；

能夠中斷任務；

能夠獲取任務執行結果。

重點：

RunnableFuture繼承了Runnable接口和Future接口，而FutureTask實現了RunnableFuture接口。

FutureTask的實現：

1	`public` `class` `FutureTask<V>` `implements` `RunnableFuture<V>`

RunnableFuture接口的實現：

									public interface RunnableFuture<V> extends Runnable, Future<V> {

									  void run();

									}

FutureTask是Future接口的一個唯一實現類。

除了可以用Thread包裝FutureTask外，還有另一種使用方法：

									ExecutorService executor = Executors.newCachedThreadPool();

									FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {

									  @Override

									  public Integer call() throws Exception {

									    // do something

									    return null;

									  }

									});

									executor.submit(futureTask);

									Integer result = futureTask.get();

這里用到了Executor 框架。

->next();

3. 關于ExecutorService,Excetor,Excutors,ThreadPoolExcetor

Executor框架在Java 5中被引入，Executor 框架是一個根據一組執行策略調用、調度、執行和控制的異步任務的框架。
在說Executor 框架之前我們需要引入一個新的概念——線程池（ThreadPoolExecutor）：

									public ThreadPoolExecutor(intcorePoolSize,

									    int maximumPoolSize,

									    long keepAliveTime,

									    TimeUnit unit,

									    BlockingQueue<Runnable> workQueue,

									    ThreadFactory threadFactory,

									    RejectedExecutionHandler handler)

ThreadPoolExecutor是Executors類的底層實現。

在JDK幫助文檔中，有如此一段話：

“強烈建議程序員使用較為方便的 Executors 工廠方法 Executors.newCachedThreadPool()（無界線程池，可以進行自動線程回收）、Executors.newFixedThreadPool(int)（固定大小線程池）和 Executors.newSingleThreadExecutor()（單個后臺線程），它們均為大多數使用場景預定義了設置。”

那么ExecutorService,Excetor,Excutors都是什么？
Excetor是一個抽象層面的核心接口：

									public interface Executor {

									  void execute(Runnable command);

									}

ExecutorService 接口對 Executor 接口進行了擴展，提供了返回 Future 對象，終止，關閉線程池等方法。

									public interface ExecutorService extends Executor {

									  void shutdown();

									  <T> Future<T> submit(Callable<T> task);

									  <T> Future<T> submit(Runnable task, T result);

									  <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException;

									}

Executors 是一個工具類，類似于 Collections。提供工廠方法來創建不同類型的線程池，比如 FixedThreadPool 或 CachedThreadPool。

									public class Executors {

									  public static ExecutorService newFixedThreadPool(int nThreads) {

									    return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,new LinkedBlockingQueue<Runnable>());

									    }

									   public static ExecutorService newCachedThreadPool() {

									    return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());

									    }

									}