public class MyFutureTaskTest {
public static void main(String[] args) {
ExecutorService executor = Executors.newCachedThreadPool();
FutureTask future = new FutureTask(new Callable() {
public String call() throws Exception{ //建议抛出异常
try {
Thread.sleep(5* 1000);
return "Hello Welcome!";
}
catch(Exception e) {
throw new Exception("Callable terminated with Exception!"); // call方法可以抛出异常
}
}
});
executor.execute(future);
long t = System.currentTimeMillis();
try {
// String result = future.get(3000, TimeUnit.MILLISECONDS); //取得结果，同时设置超时执行时间为5秒。
String result = future.get(); //取得结果，同时设置超时执行时间为5秒。
System.err.println("result is " + result + ", time is " + (System.currentTimeMillis() - t));
} catch (InterruptedException e) {
future.cancel(true);
System.err.println("Interrupte time is " + (System.currentTimeMillis() - t));
} catch (ExecutionException e) {
future.cancel(true);
System.err.println("Throw Exception time is " + (System.currentTimeMillis() - t));
// } catch (TimeoutException e) {
// future.cancel(true);
// System.err.println("Timeout time is " + (System.currentTimeMillis() - t));
} finally {
executor.shutdown();
}
}
}
运行结果如下：
result is Hello Welcome!, time is 5000
如果设置了超时时间，则运行结果如下：
Timeout time is 3000
可以看出设置超时时间的影响。
再如一个多个运行任务的例子：
public class MyAsyncExample implements Callable {
private int num;
public MyAsyncExample(int aInt) {
this.num = aInt;
}
public String call() throws Exception {
boolean resultOk = false;
if (num == 0) {
resultOk = true;
} else if (num == 1) {
while (true) { //infinite loop
System.out.println("looping....");
Thread.sleep(3000);
}
} else {
throw new Exception("Callable terminated with Exception!");
}
if (resultOk) {
return "Task done.";
} else {
return "Task failed";
}
}
public static void main(String[] args) {
//定义几个任务
MyAsyncExample call1 = new MyAsyncExample(0);
MyAsyncExample call2 = new MyAsyncExample(1);
MyAsyncExample call3 = new MyAsyncExample(2);
//初始任务执行工具。
ExecutorService es = Executors.newFixedThreadPool(3);
//执行任务，任务启动时返回了一个Future对象，
Future future1 = es.submit(call1);
Future future2 = es.submit(call2);
Future future3 = es.submit(call3);
try {
//任务1正常执行完毕，future1.get()会返回线程的值
System.out.println(future1.get());
//任务2进行一个死循环，调用future2.cancel(true)来中止此线程。
Thread.sleep(3000);
System.out.println("Thread 2 terminated? :" + future2.cancel(true));
//任务3抛出异常，调用future3.get()时会引起异常的抛出
System.out.println(future3.get());
} catch (ExecutionException ex) {
ex.printStackTrace();
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
}
运行结果如下：
looping....
Task done.
java.util.concurrent.ExecutionException: java.lang.Exception: Callable terminated with Exception!
at java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.java:222)
looping....
at java.util.concurrent.FutureTask.get(FutureTask.java:83)
Thread 2 terminated? :true
at org.jevo.future.sample.MyAsyncExample.main(MyAsyncExample.java:57)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
at java.lang.reflect.Method.invoke(Method.java:597)
at com.intellij.rt.execution.application.AppMain.main(AppMain.java:90)
Caused by: java.lang.Exception: Callable terminated with Exception!
at org.jevo.future.sample.MyAsyncExample.call(MyAsyncExample.java:30)
at org.jevo.future.sample.MyAsyncExample.call(MyAsyncExample.java:13)
at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)
at java.util.concurrent.FutureTask.run(FutureTask.java:138)
at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)
at java.lang.Thread.run(Thread.java:662)
以上是对Future模型的例子。异步调用在Swing中应该十分广泛，当客户端调用一个'重'的服务端操作时，我们常采用这种方式。Swing中存在一个Future的实现——SwingWorker，这使我们十分方便地在客户端开发中使用异步调用，详细使用参见API文档。下面附一个不使用Future来实现取得异步调用的代码，如下：
public abstract class AsyncWorker {
private Object value; //the running result
private boolean finished = false;
private static class ThreadVar {
private Thread thread;
ThreadVar(Thread t) {
thread = t;
}
synchronized Thread get() {
return thread;
}
synchronized void clear() {
thread = null;
}
}
private ThreadVar threadVar;
/**
* 返回当前线程运行结果。
*/
protected synchronized Object getValue() {
return value;
}
/**
* 设置当前线程运行结果
*/
private synchronized void setValue(Object x) {
value = x;
}
/**
* 调用都创建计算逻辑，将运算结果返回
*/
public abstract Object construct();
public void finished() {
finished = true;
}
public boolean isFinished() {
return finished;
}
public void interrupt() {
Thread t = threadVar.get();
if (t != null) {
t.interrupt();
}
threadVar.clear();
}
public void stop() {
Thread t = threadVar.get();
if(t!=null) {
t.stop();
}
threadVar.clear();
}
/**
* 返回 construct方法运行结果。
*/
public Object get() {
while (true) {
Thread t = threadVar.get();
if (t == null) {
return getValue();
}
try {
t.join();
}
catch (InterruptedException e) {
Thread.currentThread().interrupt();
return null;
}
}
}
public AsyncWorker() {
final Runnable doFinished = new Runnable() {
public void run() {
finished();
}
};
Runnable doConstruct = new Runnable() {
public void run() {
try {
setValue(construct());
}
finally {
threadVar.clear();
}
SwingUtilities.invokeLater(doFinished);
}
};
Thread t = new Thread(doConstruct);
threadVar = new ThreadVar(t);
}
/**
* Start the worker thread.
*/
public void start() {
finished = false;
Thread t = threadVar.get();
if (t != null) {
t.start();
}
}
public static void main(String[] args) {
AsyncWorker worker = new AsyncWorker() {
public Object construct() {
try {
Thread.sleep(3*1000);
}
catch(Exception e){}
return "hello world";
}
public void finished() {
super.finished();
//取线程运行返回的结果
// Object obj = this.get();
// System.err.println("return is " + obj);
}
};
long t = System.currentTimeMillis();
worker.start();
Object obj = worker.get(); //取得运行结果
System.err.println("return is " + obj + ", time = " + (System.currentTimeMillis() - t));
}
}
在上述代码中，调用者只需要扩展AsyncWorker类定义可计算的逻辑，并将逻辑结果返回。返回结果会保存在一变量中。当调用者调用返回结果时，如果计算还未完成，将调用Thread.join()阻塞线程，直到计算结果返回。用法上是不是与FutureTask相似？在Swing异步调用中，还需要结合等待对话框来表示计算运行进程，从而使运行界面显示更加友好。
再看一下线程的join方法，我们知道线程可被Object.wait、Thread.join和Thread.sleep三种方法之一阻塞，当接收到一个中断异常(InterruptedException)时，可提早地终结被阻塞状态。Thread.join的使用情况却有所不同：我们对一些耗时运算，常启用一个主线程来生成并启动一些子线程，在子线程中进行耗时的运算，当主线程继续处理完其他的事务后，需要调用子线程的处理结果，这个时候就要使用join();。Joint方法将使主线程等待子线程运行结束，即join()方法后的代码，只有等到子线程运行结束后才能被执行。参考下例：
public class ChildThread extends Thread {
public ChildThread() {
super("ChildThread");
}
public void run() {
String threadName = Thread.currentThread().getName();
System.out.println(threadName + " start.");
try {
for (int i = 0; i < 5; i++) {
System.out.println(threadName + " loop at " + i);
Thread.sleep(1000);
}
System.out.println(threadName + " end.");
} catch (Exception e) {
System.out.println("Exception from " + threadName + ".run");
}
}
}
public class ParentThread extends Thread {
ChildThread t1;
public ParentThread(ChildThread t1) {
super("ParentThread");
this.t1 = t1;
}
public void run() {
String threadName = Thread.currentThread().getName();
System.out.println(threadName + " start.");
try {
t1.join(); //ChildThread 线程t1结束后，才能运行此行代码后的代码。
System.out.println(threadName + " end.");
} catch (Exception e) {
System.out.println("Exception from " + threadName + ".run");
}
}
public static void main(String[] args) {
String threadName = Thread.currentThread().getName();
System.out.println(threadName + " start.");
ChildThread t1 = new ChildThread();
ParentThread t = new ParentThread(t1);
try {
t1.start();
Thread.sleep(2000);
t.start();
t.join();//此处注释后，将直接运行到结束代码. 注释此处代码，比较运行结果
} catch (Exception e) {
System.out.println("Exception from main");
}
System.out.println(threadName + " end!");
}
}
在t.join()被注释前运行结果如下：
main start.
ChildThread start.
ChildThread loop at 0
ChildThread loop at 1
ParentThread start.
ChildThread loop at 2
ChildThread loop at 3
ChildThread loop at 4
ChildThread end.
ParentThread end.
main end!
当t.join()被注释后运行结果如下：
main start.
ChildThread start.
ChildThread loop at 0
ChildThread loop at 1
main end!
ParentThread start.
ChildThread loop at 2
ChildThread loop at 3
ChildThread loop at 4
ChildThread end.
ParentThread end.
可见ParentThread线程仍等待ChildThread线程运行结束后才运行完毕，而Main线程与ParentThread线程的运行并没有保持等待。
378
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
