异步回调 java

异步回调 Future

 

Callback 

回调一般是异步处理的一种技术。一个回调是被传递到并且执行完该方法。 这种方式只能异步回调，如果需要同步等待线程处理结果可以使用下面介绍的Futures 

import java.util.Map;  
  
public interface ICallback {  
  
    public void callback(Map<String, Object> params);  
}  

 

import java.util.HashMap;  
import java.util.Map;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
  
public class NettyTest {  
  
    static ExecutorService es = Executors.newFixedThreadPool(2);  
  
    public static void doStm(final ICallback callback) {  
        // 初始化一个线程  
        Thread t = new Thread() {  
            public void run() {  
  
                // 这里是业务逻辑处理  
                System.out.println("do sth...");  
  
                // 为了能看出效果 ，让当前线程阻塞5秒  
                try {  
                    Thread.sleep(5000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
  
                // 处理完业务逻辑，  
                Map<String, Object> params = new HashMap<String, Object>();  
                params.put("a1", "这是我返回的参数字符串...");  
                callback.callback(params);  
            };  
        };  
  
        es.execute(t);  
    }  
  
    public static void main(String[] args) {  
  
        // 内部类 等价于 ICallback callbck = new ICallback的实现类();  
        // 新手如果对内部类的写法有疑惑可以查看一下编译后的class文件或许能明白  
        // 在编译的时候会把内部类编译成一个实现了ICallback的class  
        doStm(new ICallback() {  
            /** 
             * 现在这个方法是doStm结束后调用<br> 
             * 结束之后会主动把处理参数params传递过来 
             */  
            @Override  
            public void callback(Map<String, Object> params) {  
                System.out.println("单个线程也已经处理完毕了，返回参数a1=" + params.get("a1"));  
            }  
        });  
  
        System.out.println("主线任务已经执行完了");  
    }  
}  

Future 

Futures是一个抽象的概念，它表示一个值，该值可能在某一点变得可用。一个Future要么获得 
计算完的结果，要么获得计算失败后的异常。Java在java.util.concurrent包中附带了Future接口，它使用Executor异步执行。例 
如下面的代码，每传递一个Runnable对象到ExecutorService.submit()方法就会得到一个回调的Future，你能使用它检测是否执行，这种方法可以是同步等待线处理结果 
完成。 

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 NettyTest {  
  
    public static void main(String[] args) {  
  
        //实现一个Callable接口  
        Callable<Netty> c = new Callable<NettyTest.Netty>() {  
  
            @Override  
            public Netty call() throws Exception {  
                  
                //这里是你的业务逻辑处理  
                  
                //让当前线程阻塞5秒看下效果  
                Thread.sleep(5000);  
                return new Netty("张三");  
            }  
        };  
  
        ExecutorService es = Executors.newFixedThreadPool(2);  
          
        //记得要用submit，执行Callable对象  
        Future<Netty> fn = es.submit(c);  
          
        //无限循环等待任务处理完毕  如果已经处理完毕 isDone返回true  
        while (!fn.isDone()) {  
            try {  
                //处理完毕后返回的结果  
                Netty nt = fn.get();  
                System.out.println(nt.name);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            } catch (ExecutionException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
  
    static class Netty {  
        private Netty(String name) {  
            this.name = name;  
        }  
  
        private String name;  
    }  
}