javafuture

⑴ java的future4個線程怎麼獲取各自的返回值

1、通過進程式控制制類進行數據交換
2、設定數據交換區
3、通過網路協議進行數據交換

⑵ 求大神，Java自帶的Future多線程模式是什麼意思

理1：

什麼是Future？

用過Java並發包的朋友或許對Future (interface) 已經比較熟悉了，其實Future
本身是一種被廣泛運用的並發設計模式，可在很大程度上簡化需要數據流同步的並發應用開發。在一些領域語言（如Alice ML
）中甚至直接於語法層面支持Future。

這里就以java.util.concurrent.Future
為例簡單說一下Future的具體工作方式。Future對象本身可以看作是一個顯式的引用，一個對非同步處理結果的引用。由於其非同步性質，在創建之初，它
所引用的對象可能還並不可用（比如尚在運算中，網路傳輸中或等待中）。這時，得到Future的程序流程如果並不急於使用Future所引用的對象，那麼
它可以做其它任何想做的事兒，當流程進行到需要Future背後引用的對象時，可能有兩種情況：

希望能看到這個對象可用，並完成一些相關的後續流程。如果實在不可用，也可以進入其它分支流程。
「沒有你我的人生就會失去意義，所以就算海枯石爛，我也要等到你。」（當然，如果實在沒有毅力枯等下去，設一個超時也是可以理解的）
對於前一種情況，可以通過調用Future.isDone()判斷引用的對象是否就緒，並採取不同的處理；而後一種情況則只需調用get()或
get(long timeout, TimeUnit unit)通過同步阻塞方式等待對象就緒。實際運行期是阻塞還是立即返回就取決於get()的調用時機和對象就緒的先後了。

整理二：

什麼是Future模式呢？Future
顧名思義，在金融行業叫期權，市場上有看跌期權和看漲期權，你可以在現在（比如九月份）購買年底（十二月）的石油，假如你買的是看漲期權，那麼如果石油真
的漲了，你也可以在十二月份依照九月份商定的價格購買。扯遠了，Future就是你可以拿到未來的結果。對於多線程，如果線程A要等待線程B的結果，那麼
線程A沒必要等待B，直到B有結果，可以先拿到一個未來的Future，等B有結果是再取真實的結果。其實這個模式用的很多，比如瀏覽器下載圖片的時候，
剛開始是不是通過模糊的圖片來代替最後的圖片，等下載圖片的線程下載完圖片後在替換。

補充：

當另外一個線程需要使用某一個線程的結果時，可以通過Future引用的get()方法去獲得，如果結果還未出來，調用此方法的線程被block，直到結果出來。（這種機制是為了更好地適應多線程環境）

⑶ java多線程中的callable和future常用在哪些地方

運行Callable任務可以拿到一個Future對象，表示非同步計算的結果。
用於Java多線程開發
工具/原料
Java IDE
方法/步驟

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableTest{
public static void main(String [] args ) {
String [] words = {"first","second","world","thread"};

ExecutorService pool = Executors.newCachedThreadPool();
Set<Future<Integer>> set = new HashSet<Future<Integer>>();

for (String word:words) {
Callable callable = new testCallable(word);
Future future = pool.submit(callable);
set.add(future);
}
int sum = 0;
for (Future future:set) {
try {
sum += (int)future.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
System.out.println("數組中所有單詞的總長度為：" + sum);
}

}

class testCallable implements Callable{
private String word;

public testCallable(String word){

this.word = word;
}

@Override
public Integer call() throws Exception {
System.out.println(Thread.currentThread().getName() + ": 開始執行" );
try {
Thread.currentThread().sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ": 正在處理" );
System.out.println(Thread.currentThread().getName() + ": " + word + "長度為：" + word.length());
return Integer.valueOf(word.length());
}
}
pool-1-thread-2: 開始執行
pool-1-thread-4: 開始執行
pool-1-thread-3: 開始執行
pool-1-thread-1: 開始執行
pool-1-thread-1: 正在處理
pool-1-thread-1: first長度為：5
pool-1-thread-3: 正在處理
pool-1-thread-3: world長度為：5
pool-1-thread-2: 正在處理
pool-1-thread-2: second長度為：6
pool-1-thread-4: 正在處理
pool-1-thread-4: thread長度為：6
數組中所有單詞的總長度為：22

⑷ Java的Runnable，Callable，Future，FutureTask有什麼區別

Runnable ，Callable 都是線程介面 ，並且Callable 和Runnable挺相似 ，
但是 Runnable 是無法返回一個值 ，而Callable可以
Future 也是線程介面 ，和以上兩的區別主要是提供了非同步執行 ，並可以通過get返回結果，中途可以cancel
FutureTask實現了Future介面外還實現了Runnable介面，因此FutureTask也可以直接提交給Executor執行

⑸ 什麼是java future模式

用過Java並發包的朋友或許對Future (interface) 已經比較熟悉了，其實Future 本身是一種被廣泛運用的並發設計模式，可在很大程度上簡化需要數據流同步的並發應用開發。在一些領域語言（如Alice ML ）中甚至直接於語法層面支持Future。

⑹ java協程和futuretask的區別

Callable要採用ExecutorSevice的submit方法提交,返回Future對象,通過Future的get()方法,同步拿到線程的返回結果,實例代碼如下:
public class ThreadExample12 { public static void main(String[] args) {
ExecutorService threadPool = Executors.newSingleThreadExecutor();
Future<String> future = threadPool.submit(new Callable<String>() { public String call() throws Exception {
Thread.sleep(2000); return "Hello World";
};
});

System.out.println("等待結果"); try {
System.out.println("返回結果為:" + future.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
}

Future取得的結果類型和Callable返回的結果類型必須一致,這是通過泛型來實現的。Callable要採用ExecutorSevice的submit方法提交,返回的Future對象可以取消任務,通過調用Future的future.cancel(true)方法實現,Future對象還可以對超時線程進行關閉,通過future.wait(3);如果線程耗時超過3秒則拋出異常
在這里有人可能會有疑問,既然要同步返回結果,那我為什麼要再開一個線程去執行呢,還不如直接在主線程執行就好。但是這種是局限於在一個線程時,如果需要同時執行多個線程,等待多個線程返回結果時,在主線程中是不能實現這種功能的。可以看一下實例代碼,就能明白了:
public class ThreadExample13 { public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(10);
CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(threadPool); for (int i = 1; i <= 10; i++) {
final int seq = i;
completionService.submit(new Callable<Integer>() {
@Override public Integer call() throws Exception {
Thread.sleep(new Random().nextInt(5000)); return seq;
}
});
} for (int i = 0; i < 10; i++) { try {
System.out.println(completionService.take().get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
}