异步线程的两种方法Callback 和 Future&Runnable

●介绍

有时候执行一个任务需要很长时间，单线程下线程会处于阻塞状态。这个时候我们会考虑一种非阻塞的处理模式。非阻塞任务在任何编程语言里都必不可少，Java也不例外。多线程就是一个很好的解决办法。
但是多线程是异步处理，异步就意味着不知道处理结果，如果我们需要知道处理结果的时候应该怎么办呢？ 笔者介绍下面两种方法

●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;
	}
}