Future
Future是J.U.C中的一个接口，它代表着一个异步执行结果。
Future可以看成线程在执行时留给调用者的一个存根，通过这个存在可以进行查看线程执行状态(isDone)、取消执行(cancel)、阻塞等待执行完成并返回结果(get)、异步执行回调函数(callback)等操作。
public interface Future<V> {
/** 取消，mayInterruptIfRunning-false:不允许在线程运行时中断 **/
boolean cancel(boolean mayInterruptIfRunning);
/** 是否取消**/
boolean isCancelled();
/** 是否完成 **/
boolean isDone();
/** 同步获取结果 **/
V get() throws InterruptedException, ExecutionException;
/** 同步获取结果，响应超时 **/
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
用ReentrantLock实现Future
一个小栗子：
public class ResponseFuture implements Future<String> {
private final ResponseCallback callback;
private String responsed;
private final ReentrantLock lock = new ReentrantLock();
private final Condition condition = lock.newCondition();
public ResponseFuture(ResponseCallback callback) {
this.callback = callback;
}
public boolean isDone() {
return null != this.responsed;
}
public String get() throws InterruptedException, ExecutionException {
if (!isDone()) {
try {
this.lock.lock();
while (!this.isDone()) {
condition.await();
if (this.isDone()) break;
}
} finally {
this.lock.unlock();
}
}
return this.responsed;
}
// 返回完成
public void done(String responsed) throws Exception{
this.responsed = responsed;
try {
this.lock.lock();
this.condition.signal();
if(null != this.callback) this.callback.call(this.responsed);
} finally {
this.lock.unlock();
}
}
public String get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
throw new UnsupportedOperationException();
}
public boolean cancel(boolean mayInterruptIfRunning) {
throw new UnsupportedOperationException();
}
public boolean isCancelled() {
throw new UnsupportedOperationException();
}
}
使用这个Future：
public class ResponseCallback {
public String call(String o) {
System.out.println("ResponseCallback：处理完成，返回："+o);
return o;
}
}
public class FutureTest {
public static void main(String[] args) {
final ResponseFuture responseFuture = new ResponseFuture(new ResponseCallback());
new Thread(new Runnable() {// 请求线程
public void run() {
System.out.println("发送一个同步请求");
// System.out.println(responseFuture.get()); 放开这句，就是同步
System.out.println("接着处理其他事情,过一会ResponseCallback会打印结果");
}
}).start();
new Thread(new Runnable() {// 处理线程
public void run() {
try {
Thread.sleep(10000);// 模拟处理一会
responseFuture.done("ok");// 处理完成
}catch (Exception e) {
e.printStackTrace();
}
}).start();
}
}
这个Future使用了Condition的await和signal方法
同步操作：调用get时如果发现未有结果返回，线程阻塞等待，直到有结果返回时通知Future唤醒等待的线程。
异步操作：调用线性不用等待，有结果返回时调用signal()发现没有等待线程，直接调用Callback。
FutureTask
FutureTask是J.U.C中Future的实现，它同时也实现了Runnable接口，可以直接在ExecutorService中提交执行这个Future。
一个小栗子：
public class FutureTaskTest {
public static class CallableImpl implements Callable<String>{
public String call() throws Exception {
String tName = Thread.currentThread().getName();
System.out.println(tName+" :开始执行");
Thread.sleep(6000);
return tName+" ok";
}
}
public static void main(String[] args) throws Exception {
ExecutorService es = Executors.newFixedThreadPool(1);
// // 同步执行，等待6000毫秒拿到结果
// FutureTask<String> future = new FutureTask<String>(new CallableImpl());
// es.submit(future);
// System.out.println(future.get());
// 异步执行
FutureTask<String> future = new FutureTask<String>(new CallableImpl()) {
protected void done() {
try {
System.out.println("异步返回的结果："+this.get());
} catch (Exception e) {
e.printStackTrace();
}
}
};
es.submit(future);
System.out.println("执行其他操作");
es.shutdown();
}
}
FutureTask实现
使用单向链表WaitNode表示排队等待的线程， volatile state表示当前线程的执行状态，状态转换如下：
NEW -> COMPLETING -> NORMAL
NEW -> COMPLETING -> EXCEPTIONAL
NEW -> CANCELLED
NEW -> INTERRUPTING -> INTERRUPTED
awaitDone
阻塞等待
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
boolean queued = false;
for (;;) {
if (Thread.interrupted()) {// 当前线程中断
removeWaiter(q);// 移除等待的节点
throw new InterruptedException();
}
int s = state;// 当前状态
if (s > COMPLETING) {//已经执行完成
if (q != null)
q.thread = null;// 节点绑定的线程置空
return s;
}
else if (s == COMPLETING) //完成中
Thread.yield();// 出让CPU
else if (q == null)// 等待节点为空，构建节点
q = new WaitNode();
else if (!queued)// waiters设置为q
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
else if (timed) {
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {// 超时，摘除节点
removeWaiter(q);
return state;
}
LockSupport.parkNanos(this, nanos);//挂起线程，响应超时
}
else
LockSupport.park(this);// 挂起线程
}
}
run
线程执行
// s1
public void run() {
// state!=NEW,说明没必要执行，返回。
// CAS操作，将runner设置为当前线程，如果失败，说明有其他线程在执行，返回。
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();//执行
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);// 异常 s2
}
if (ran)
set(result);// 完成 s3
}
} finally {
runner = null;// 置空runner
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
s1:state不为NEW或者有其他线程在执行时，都不会执行run方法。
执行中出现异常转入s2
执行结束转入s3
// s2
protected void setException(Throwable t) {
// 完成 NEW-COMPLETING-EXCEPTIONAL 状态置换
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = t;
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
finishCompletion();
}
}
s2:这步完成状态：NEW-COMPLETING-EXCEPTIONAL 置换
将异常赋给结果outcome
转入s4
// s3
protected void set(V v) {
// 完成NEW-COMPLETING-NORMAL状态置换
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();
}
}
s3:这步完成状态：NEW-COMPLETING-NORMAL 置换
将执行结果赋给outcome
转入s4
// s4
private void finishCompletion() {
for (WaitNode q; (q = waiters) != null;) {
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {//waiters置空
for (;;) {// 依次唤醒所有等待的节点
Thread t = q.thread;
if (t != null) {
q.thread = null;// 置空
LockSupport.unpark(t);// 唤醒
}
WaitNode next = q.next;//向后探测
if (next == null)
break;
q.next = null; // unlink to help gc
q = next;
}
break;
}
}
done();// 回调钩子
callable = null; // to reduce footprint
}
s4:for(;;)中异常唤醒等待线程
调用回调钩子done()
被唤醒的线程会在awaitDone中让出CPU，退出循环。
小结
1、Future代表着一个异步执行结果
2、get是同步操作，当前线程会阻塞等待执行完毕，返回结果
3、异步操作使用钩子进行回调，不阻塞当前线程
