使用回调和线程处理一个耗时响应过程

使用回调和线程处理一个耗时响应过程

现在程序中有许多涉及长耗时响应过程的处理，比如访问WebService,远程调用，复杂处理等，如果我们使用直接顺序执行的方式进行处理有可能导致界面停顿，响应停止，无谓等待等缺陷，这是不应该的。

一个耗时响应过程应该采用回调和线程来处理，具体就是把原来的顺序执行修改为异步方式，并让被调用者调用调用者以获得执行结果。在附件的例子中，Viewer就是调用者，它代表界面，而LongTimeResponse是被调用者，它内部用线程启动一个耗时过程，执行完毕再通知调用者。

Viewer类代码如下：
public class Viewer{
private int count;

public Viewer(int count){
this.count=count;
}

public void printNewCount(int newCount){
System.out.println("New Count="+newCount);
}

public int getCount() {
return count;
}

public void setCount(int count) {
this.count = count;
}
}
LongTimeResponse类代码如下，可以看出，它之所以能回调调用者，是因为其内部有调用者的引用viewer，在其构造函数中viewer被赋上了值：
public class LongTimeResponse implements Runnable{
private Viewer viewer;
private int count;

public LongTimeResponse(Viewer viewer){
this.viewer=viewer;
this.count=viewer.getCount();

caculateNewCount();
}

private void caculateNewCount(){
Thread thread=new Thread(this);
thread.start();
}

public void run(){
try{
Thread.sleep(10000);
}
catch(Exception ex){
ex.printStackTrace();
}

viewer.printNewCount(count*count*count);
}
}
调用过程如下：
public class Inlet {
public static void main(String[] arg) {
Viewer viewer=new Viewer(10);
LongTimeResponse longTimeResponse=new LongTimeResponse(viewer);

viewer.printNewCount(123);
}
}

执行起来可以看出，程序先输出了
New Count=123
过了十秒，才输出：
New Count=1000

这说明，程序是异步执行的，耗时过程没有影响到主干程序的运行，而耗时过程完成后，才把返回结果通知了调用者，主干程序没有受到耗时过程的影响，因此也就不会导致界面停顿，响应停止，无谓等待等缺陷。

以上就是使用回调和线程处理一个耗时响应的整个过程。

来自java编程思想：
闭包是一个可调用的对象，它记录了一些信息，这些信息来自于创建他的作用域，用过这个定义 可以看出内部类是面向对象的闭包 因为他不仅包含外围类对象的信息 还自动拥有一个指向此外围类对象的引用 在此作用域内 内部类有权操作所有的成员 包括private成员；
interface Incrementable
{
void increment();
}

class Callee1 implements Incrementable
{
private int i=0;
public void increment()
{
i++;
System.out.println(i);
}
}
class MyIncrement
{
void increment()
{
System.out.println("other increment");
}
static void f(MyIncrement mi)
{
mi.increment();
}
}
class Callee2 extends MyIncrement
{
private int i=0;
private void incr()
{
i++;
System.out.println(i);
}
private class Closure implements Incrementable
{
public void increment()
{
incr();
}
}
Incrementable getCallbackReference()
{
return new Closure();
}
}
class Caller
{
private Incrementable callbackRefference;
Caller(Incrementable cbh)
{
callbackRefference = cbh;
}
void go()
{
callbackRefference.increment();
}
}
public class Callbacks
{
public static void main(String [] args)
{
Callee1 c1=new Callee1();
Callee2 c2=new Callee2();
MyIncrement.f(c2);
Caller caller1 =new Caller(c1);
Caller caller2=new Caller(c2.getCallbackReference());
caller1.go();
caller1.go();
caller2.go();
caller2.go();
}
}
输出
other increment
1
2
1
2
Callee2继承字MyIncrement 后者已经有一个不同的increment（）方法 并且与Incrementable接口期望的increment（）方法完全不相关 所以如果Callee2继承了MyIncrement 就不能为了Incrementable的用途而覆盖increment（）方法 于是这能使用内部类独立的实现Incrementable
内部类Closure实现了Incrementable 一提供一个放回Caller2的钩子 而且是一个安全的钩子 无论谁获得此Incrementbale的引用 都只能调用increment（） 除此之外没有其他功能