Java中的Future

1.Future解决了什么问题

Future是java中的一个接口，主要用于java多线程计算过程的异步结果获取，能够感知计算的进度，与传统的多线程实现方式，比如继承Thread类，实现runnable接口，它们主要的局限在于对多线程运行的本身缺少监督。

2.Callable接口和Runnable接口区别

下面是它们之间的主要区别:

1. runable接口是用run方法作为线程运行任务的入口，callable接口使用call方法
2. call方法抛出异常，run方法不抛出异常，也就是说实现callable接口，可以对线程运行任务时的出错抛出的异常进行捕获，从而得知任务异常的原因
3. 运行Callable任务可拿到一个Future对象， Future表示异步计算的结果
4. callable的实现类FutureTask提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。

3.java实现线程的三种方式:

继承Thread类

class MyThread extends Thread{

private String str;

public MyThread(String str){

this.str = str;

}

public void run() {

for (int i = 0; i < 10; i++) {

System.out.println(this.str+"="+i);

}

}

}

public class Test {

public static void main(String[] args) {

new MyThread("线程一").start();

new MyThread("线程二").start();

new MyThread("线程三").start();

}

}

实现Runnable接口

public MyRunnable implements Runnable{ 
public void run(){ 
for(int i = 0;i<100;i++){ 
System.out.println(i); 
} 
} 
}

public class MyRunnableDemo{ 
public static void main(String[] args){ 
MyRunnable my = new MyRunnable(); 
Thread t1 = new Thread(my,”线程1”); 
Thread t2 = new Thread(my,”线程2”); 
t1.start(); 
t2.start(); 
} 
}

实现Callable接口

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.FutureTask;

 

class MyThread implements Callable<String>{

private String title;

public MyThread(String title){

this.title = title;

}

public String call()throws Exception{

for (int i = 0; i < 10; i++) {

System.out.println(title+"i="+i);

}

return "线程执行完毕";

}

}

public class Test {

public static void main(String[] args) throws InterruptedException, ExecutionException {

FutureTask<String> task1 = new FutureTask<>(new MyThread("线程一"));

FutureTask<String> task2 = new FutureTask<>(new MyThread("线程二"));

new Thread(task1).start();

new Thread(task2).start();

System.out.println("线程返回数据一"+ task1.get());

System.out.println("线程返回数据二"+ task2.get());

}

}

三种实现方式都能够达到多线程运算的目的，但是适用场景却不同。
继承Thread类实现多线程是最为简洁的方式，但是由于Java是单继承，继承了Thread类就不能继承其他的类，影响了类的扩展性。

实现Runnable接口是为了规避ava单继承的问题，

实现Callable接口则是为了满足获取异步计算结果，对线程计算更为可控设计的。

4.实现callable接口如何使异步计算更为可控？

通常为了达到多线程并发运行任务，需要利用Java的Thread类，要么继承它，要么传递一个Runnable对象给Thread类，然后通过调用它的start方法，运行异步计算任务。那么实现callable的接口如何利用Thread类来达到多线程并发运行的目的呢？

答案是FutureTask，FutureTask类：包装callable接口，并同时实现了Runable接口和Future接口，实现Runnable接口是为了满足多线程并发执行的目的，实现Future接口则是为了满足多线程并发过程中新线程不可控问题。

FutureTask的构造方法:

    public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }

从上面可以看出FutureTask类将Callable接口作为自己的私有成员变量，作为操作的起点。
而state则是FutureTask封装的callable实现类的call方法的状态变量，主要是了解异步任务的状态

它主要定义了6种状态，

     * Possible state transitions:
     * NEW -> COMPLETING -> NORMAL
     * NEW -> COMPLETING -> EXCEPTIONAL
     * NEW -> CANCELLED
     * NEW -> INTERRUPTING -> INTERRUPTED
     */
    private volatile int state;
    private static final int NEW          = 0;
    private static final int COMPLETING   = 1;
    private static final int NORMAL       = 2;
    private static final int EXCEPTIONAL  = 3;
    private static final int CANCELLED    = 4;
    private static final int INTERRUPTING = 5;
    private static final int INTERRUPTED  = 6;

根据它的命名可以很清楚的明白，各个常量所代表的含义。
NEW代表异步计算还没开始，
COMPLETING 代表计算正在进行中
NORMAL 代表计算正常结束
EXCEPTIONAL 代表计算过程中出现了异常
CANCELLED 代表计算任务被取消
INTERRUPTING 代表计算任务正在被中断执行
INTERRUPTED 代表计算任务已经被中断执行

接着来看，FutureTask的run方法实现:

  public void run() {
  		1。判断计算状态，如果不为NEW，结束
        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 {
                 //2 .执行实现Callable类的call方法
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    //3. 异常捕捉
                    setException(ex);
                }
                if (ran)
                	//4. 结果回显
                    set(result);
            }
        } finally {
            // runner must be non-null until state is settled to
            // prevent concurrent calls to run()
            runner = null;
            // state must be re-read after nulling runner to prevent
            // leaked interrupts
            int s = state;
            //5. 解决中断
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

从FutureTask的run方法，可以看出，它是在以自己作为新线程的入口，执行传递给自己的callable实现类的call方法，并将call方法的返回值保存在自己的私有成员变量中。

在上面代码3处，主要是做了异常封装的工作。

    protected void setException(Throwable t) {
        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
            outcome = t;
            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
            finishCompletion();
        }
    }

outcome被设计为Object类型，这样它既可以接受异步计算的结果，又可以接受一个Exception异常，
finishCompletion();方法，主要是为了唤醒因调用get方法阻塞的线程。

 private void finishCompletion() {
        // assert state > COMPLETING;
        for (WaitNode q; (q = waiters) != null;) {
            if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
                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
    }

最后来看最为重要的get方法实现:

public V get() throws InterruptedException, ExecutionException {
        int s = state;
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }

FutureTask主要用state变量来了解实现callable类的call方法计算的状态，当计算状态为开始NEW或者正在计算COMPLETING，那么需要考虑阻塞当前线程。阻塞是用awaitDown方法实现的。

 private int awaitDone(boolean timed, long nanos)
        throws InterruptedException {
        final long deadline = timed ? System.nanoTime() + nanos : 0L;
        WaitNode q = null;
        boolean queued = false;
        for (;;) {
            1. 在get阻塞中设置线程的interrupt标志位，可以使其跳出等待
            if (Thread.interrupted()) {
              2.将线程的waitor从等待链表中移除
                removeWaiter(q);
                throw new InterruptedException();
            }
			3.如果进入方法后查看state，发现state已经大于计算中，则可以退出等待返回结果
            int s = state;
            if (s > COMPLETING) {
                if (q != null)
                    q.thread = null;
                return s;
            }
            4. 如果快计算完，降低线程优先级，降低获取CPU可能性
            else if (s == COMPLETING) // cannot time out yet
                Thread.yield();
            else if (q == null)
                q = new WaitNode();
            else if (!queued)
                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);
        }
    }