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();
}
}
}
}