java线程返回值
㈠ java回调以及如何获取线程的执行结果
软件模块之间存在调用的接口，从调用方式来看，有同步调用、回调、异步调用这三种方式：
同步调用是是一种阻塞式调用，调用方要等待被调用方执行完毕返回后才能获取调用的执行结果，是一种单向调用。
回调是一种双向调用，调用方在执行被调用方后，被调用方会调用被调用方的接口；
异步调用是一种类似消息或者事件的机制，接口在收到某个消息或发生某事件时，会主动通知客户方，通常使用回调来实现异步调用。
Java回调的必须要素：
1.雇主类必须有可以被观察者调用的方法A；
2.观察者必须持有可以调用A的对象的引用。
在实际工作中，我们通常将方法A以interface或者内部类的形式来实现，然后把包含有A的类的对象引用传递到观察者中。
Java中的线程的返回值是void，并且是一个异步执行流，所以我们没有直接的方法来获取线程执行后的结果，即不能直接知道线程何时结束，以及合适去获取线程执行任务后的结果。由于回调的存在，我们可以在线程中以回调的方式通知线程的调用者线程的结束时间，并可以将任务的结果通过回调回送到调用者中。
㈡ java 多线程 有返回值怎么实现
作为一个完全面向对象的语言，Java提供了类 Java.lang.Thread 来方便多线程编程，这个类提供了大量的方法来方便我们控制自己的各个线程，我们以后的讨论都将围绕这个类进行。 Thread 类最重要的方法是 run()
㈢ java 如何创建一个有返回值的线程
可以通过实现Callable接口创建一个有返回值的线程，代码如下：
importjava.util.concurrent.*;
<Integer>{
privateintcount;
publicMyThread(intcount){
this.count=count;
}
@Override
publicIntegercall()throwsException{
//此处是线程要处理的业务代码，此处实现的是对count变量加1的操作
count+=1;
Thread.sleep(1000);
returncount;
}
publicstaticvoidmain(String[]args){
//创建线程实例
MyThreadmyThread=newMyThread(1);
//创建一个大小为10的线程池
ExecutorServiceexecutor=Executors.newFixedThreadPool(10);
//将线程提交到线程池执行
Future<Integer>future=executor.submit(myThread);
try{
//调用get方法获取线程执行结果，在线程执行完成前该方法会一直阻塞
Integerresult=future.get();
System.out.println(result);
}catch(InterruptedExceptione){
e.printStackTrace();
}catch(ExecutionExceptione){
e.printStackTrace();
}
//try{
////这种写法可以设置线程执行的超时时间，当线程超过指定的时间还未执行完成时会抛出TimeoutException异常
////示例中表示线程超过1000毫秒还没执行完就会抛出超时异常
//Integerresult=future.get(1000,TimeUnit.MILLISECONDS);
//System.out.println(result);
//}catch(InterruptedExceptione){
//e.printStackTrace();
//}catch(ExecutionExceptione){
//e.printStackTrace();
//}catch(TimeoutExceptione){
//e.printStackTrace();
//}
}
}
㈣ JAVA多线程问题，想让每次线程运行后都能返回值给成员变量，要如何修改
把a定义成公共的，在thread里i++时，a也跟着++就行，，不过你的代码怎么构造出了好几个线程？？？如果这几个线程公用一个i变量，那么Thread1需要实现Runnable接口，而不是继承Thread类
publicclassXianChengNew{
publicstaticinta=0;
publicstaticvoidmain(String[]args){
Thread1t1=null;
t1=newThread1(a);
t1.start();
booleanflag=true;
while(flag){
if(!t1.isAlive()){
flag=false;
}
}
System.out.println("Maina="+a);
}
}
classThread1extendsThread{
privateinti=0;
publicThread1(inti){
super();
this.i=i;
}
@Override
publicvoidrun(){
//super.run();
//for(ints=0;s<100;s++){
add();
//}
}
synchronizedvoidadd(){
for(intc=0;c<5;c++){
i++;
XianChengNew.a++;
System.out.println("i="+i);
System.out.println("a="+XianChengNew.a);
}
}
}
㈤ java 线程中的值如何返回
如果是java5的话，那么Java5新增了Callable接口获得线程的返回值，用法如下
packagecom.ronniewang;
importjava.util.concurrent.Callable;
importjava.util.concurrent.ExecutionException;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importjava.util.concurrent.Future;
{
privatestaticfinalintSLEEP_MILLS=3000;
privatestaticfinalintSECOND_MILLS=1000;
privatestaticintsleepSeconds=SLEEP_MILLS/SECOND_MILLS;
=Executors.newCachedThreadPool();
/**
*在创建多线程程序的时候，我们常实现Runnable接口，Runnable没有返回值，要想获得返回值，Java5提供了一个新的接口Callable
*/
publicstaticvoidmain(String[]args){
newGetReturnValueFromCallable().testCallable();
}
privatevoidtestCallable(){
/**
*Callable需要实现的是call()方法，而不是run()方法，返回值的类型有Callable的类型参数指定，
*Callable只能由ExecutorService.submit()执行，正常结束后将返回一个future对象
*/
Future<String>future=executorService.submit(newCallable<String>(){
publicStringcall()throwsException{
Thread.sleep(SLEEP_MILLS);
return"Ifromcallable";
}
});
while(true){
/**
*获得future对象之前可以使用isDone()方法检测future是否完成，完成后可以调用get()方法获得future的值，
*如果直接调用get()方法，get()方法将阻塞值线程结束
*/
if(future.isDone()){
try{
System.out.println(future.get());
break;
}catch(InterruptedExceptione){
//ignored
}catch(ExecutionExceptione){
//ignored
}
}
else{
try{
System.out.println("after"+sleepSeconds--+"seconds,wewillgetfuture");
Thread.sleep(SECOND_MILLS);
}catch(InterruptedExceptione){
//ignored
}
}
}
}
}
packagecom.ronniewang;
importjava.util.concurrent.Callable;
importjava.util.concurrent.ExecutionException;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importjava.util.concurrent.Future;
{
privatestaticfinalintSLEEP_MILLS=3000;
privatestaticfinalintSECOND_MILLS=1000;
privatestaticintsleepSeconds=SLEEP_MILLS/SECOND_MILLS;
=Executors.newCachedThreadPool();
/**
*在创建多线程程序的时候，我们常实现Runnable接口，Runnable没有返回值，要想获得返回值，Java5提供了一个新的接口Callable
*/
publicstaticvoidmain(String[]args){
newGetReturnValueFromCallable().testCallable();
}
privatevoidtestCallable(){
/**
*Callable需要实现的是call()方法，而不是run()方法，返回值的类型有Callable的类型参数指定，
*Callable只能由ExecutorService.submit()执行，正常结束后将返回一个future对象
*/
Future<String>future=executorService.submit(newCallable<String>(){
publicStringcall()throwsException{
Thread.sleep(SLEEP_MILLS);
return"Ifromcallable";
}
});
while(true){
/**
*获得future对象之前可以使用isDone()方法检测future是否完成，完成后可以调用get()方法获得future的值，
*如果直接调用get()方法，get()方法将阻塞值线程结束
*/
if(future.isDone()){
try{
System.out.println(future.get());
break;
}catch(InterruptedExceptione){
//ignored
}catch(ExecutionExceptione){
//ignored
}
}
else{
try{
System.out.println("after"+sleepSeconds--+"seconds,wewillgetfuture");
Thread.sleep(SECOND_MILLS);
}catch(InterruptedExceptione){
//ignored
}
}
}
}
}
输出结果：
after3seconds,wewillgetfuture
after2seconds,wewillgetfuture
after1seconds,wewillgetfuture
Ifromcallable
㈥ 如何在java中获取线程异步执行之后的结果
java中提供了Future<V>接口和实现了Future接口的FutureTask<V> 类来将线程执行之后的结果返回（通过get()方法）。
1.Future<V>接口
Runnable接口执行任务是不返回任何值的，Runnable的run()方法的执行结果是void,而Future接口的call方法是有返回结果的，这是Runnable跟Future的区别之一，它们的另一个不同之处就是实现了Runnable接口的任务执行是调用ExecutorService的execute(Runnable task)方法，而实现了Future接口的任务是调用ExecutorService的submit(Future task)方法。调用Future的get()方法就能直接得到任务的返回值，该方法会一直阻塞直到任务的结果出来为止，我们可以调用Future的isDone()方法来判断该任务的结果是否准备就绪。
[java] view plain
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 TestFuture {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executor = Executors.newCachedThreadPool();
Future result1 = executor.submit(new Callable() {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 0; i < 10; i++) {
sum += i;
}
return sum;
}
});
Future result2 = executor.submit(new Callable() {
@Override
public Integer call() throws Exception {
int sum = 0;
for (int i = 10; i < 100; i++) {
sum += i;
}
return sum;
}
});
executor.shutdown();
System.out.println(result1.get() + result2.get());
}
}
2.FutureTask类
FutureTask实现了Future接口，将一个Callable实例作为参数传给它，就能创建一个FutureTask实例，然后用ExecutorService的submit方法来执行这个实例。最后同样是用get方法获取线程执行后的结果。
[plain] view plain
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
public class TestFutureTask {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService executor = Executors.newCachedThreadPool();
Callable task = new Callable() {
@Override
public String call() throws Exception {
return "结果";
}
};
FutureTask ft = new FutureTask(task);
executor.submit(ft);
System.out.println(ft.get());
executor.shutdown();
}
}empty