Future

FutureTask

FutureTask可用于异步获取执行结果或取消执行任务的场景。通过传入Runnable或者Callable的任务给FutureTask,直接调用其run方法或者放入线程池执行，之后可以在外部通过FutureTask的get方法异步获取执行结果.

 

 

Callable()

public interface Callable<V> {
    V call() throws Exception;
}

 public class FutureTask<V> implements RunnableFuture<V> {     

　　void run();

}

Future 实际是Runnable的子类

 

Runnable 和 Callable 的区别

Runnable 的run 方法是被线程调用的，在run 方法是异步执行的

callable 的call 方法，不是异步执行的,是由Future的run调用的

 

 

FutureTask

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

里面维护了Callable,状态指定为new

    public FutureTask(Runnable runnable, V result) {
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }

 

当我们把FutureTask看作一个Future，那么它的作用就是控制Callable的call方法的执行过程，在执行的过程中自然会有状态的转换

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
（执行过程出现异常）NEW -> COMPLETING -> EXCEPTIONAL
（执行过程被取消）NEW -> CANCELLED
（执行过程中，线程中断）NEW -> INTERRUPTING -> INTERRUPTED

 

 

把FutureTask提交到线程池或者线程执行start时候会调用run方法，源码如下

run()方法

public void run() {

    //如果当前不是new状态，或者当前cas设置当前线程失败则返回，只有一个线程可以成功。
    if (state != NEW ||
        !UNSAFE.compareAndSwapObject(this, runnerOffset,
                                     null, Thread.currentThread()))
        return;
    try {
        //当前状态为new 则调用任务的call方法执行任务
        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);完成NEW -> COMPLETING -> EXCEPTIONAL 状态转移
            }

            //执行任务成功则保存结果更新状态，unpark所有等待线程。
            if (ran)
                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;
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

set()

 protected void set(V v) {
     //状态从new->COMPLETING
   if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        outcome = v;
        //状态从COMPLETING-》NORMAL
        UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
        //unpark所有等待线程。
        finishCompletion();
    }
 }

Future()的返回，get()方法

public V get() throws InterruptedException, ExecutionException {
        int s = state;
        //当状态值<=COMPLETING时候需要等待，否者调用report返回
        if (s <= COMPLETING)
            s = awaitDone(false, 0L);
        return report(s);
    }

 

awaitOne();

 9     private int awaitDone(boolean timed, long nanos)
10             throws InterruptedException {
11         final long deadline = timed ? System.nanoTime() + nanos : 0L;
12         WaitNode q = null;
13         boolean queued = false;
14         for (;;) {
15 
16             //如果被中断，则抛异常
17             if (Thread.interrupted()) {
18                 removeWaiter(q);
19                 throw new InterruptedException();
20             }
21 
22             //组建单列表
23             int s = state;
24             if (s > COMPLETING) {
25                 if (q != null)
26                     q.thread = null;
27                 return s;
28             }
29             else if (s == COMPLETING) // cannot time out yet
30                 Thread.yield();
31             else if (q == null)//成立
32                 q = new WaitNode();
33             else if (!queued)
34                 queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
35                         q.next = waiters, q);
36             else if (timed) {
37 
38 
39                 nanos = deadline - System.nanoTime();
40                 //超时则返回
41                 if (nanos <= 0L) {
42                     removeWaiter(q);
43                     return state;
44                 }
45                 //否者设置park超时时间
46                 LockSupport.parkNanos(this, nanos);
47             }
48             else
49                 //直接挂起当前线程
50                 LockSupport.park(this);
51         }
52     }

1、计算deadline，也就是到某个时间点后如果还没有返回结果，那么就超时了。
2、进入自旋，也就是死循环。
3、首先判断是否响应线程中断。对于线程中断的响应往往会放在线程进入阻塞之前，这里也印证了这一点。
4、判断state值，如果>COMPLETING表明任务已经取消或者已经执行完毕，就可以直接返回了。
5、如果任务还在执行，则为当前线程初始化一个等待节点WaitNode，入等待队列。这里和AQS的等待队列类似，只不过、Node只关联线程，而没有状态。AQS里面的等待节点是有状态的。
7、计算nanos，判断是否已经超时。如果已经超时，则移除所有等待节点，直接返回state。超时的话，state的值仍然还是COMPLETING。
8、如果还未超时，就通过LockSupprot类提供的方法在指定时间内挂起当前线程，等待任务线程唤醒或者超时唤醒。

 

get方法最后调用了report方法：

53     
54     private V report(int s) throws ExecutionException {
55         Object x = outcome;
56         //状态值为NORMAL正常返回
57         if (s == NORMAL)
58             return (V)x;
59         //状态值大于等于CANCELLED则抛异常
60         if (s >= CANCELLED)
61             throw new CancellationException();
62         throw new ExecutionException((Throwable)x);
63     }

 

举例：

提前完成任务之Future task

public class Demo {

    public static void main(String[] args) throws Exception {
    Callable<Integer> call = new Callable<Integer>() {
        @Override
        public Integer call() throws Exception {
            Thread.sleep(1000);
            return 1;
        }
    };
        FutureTask<Integer> task = new FutureTask<>(call);

        Thread thread = new Thread(task);

        thread.start();

        //do else

        System.out.println("干点别的");

        Integer result = task.get();

        System.out.println("拿到的结果为："+result);
    }

}

Console:

干点别的
拿到的结果为：1

 

 

举例2：上班订蛋糕，下班取蛋糕

 

productFactory :生产产品，返回订单

public class ProductFactory {

    public Future createProduct(String name){
        

        Future f = new Future();
        System.out.println("下单成功了，可以去上班了...");
        new Thread(new Runnable() {
            @Override
            public void run() {
                Product p = new Product(new Random().nextInt(),name);
                f.setProduct(p);
            }
        }).start();
        return f;
    }

}

Product

public class Product {

    private int id;
    private String name;

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Product{" + "id=" + id + ", name='" + name + '\'' + '}';
    }

    public Product(int id, String name) {
        System.out.println("开始生产..."+name);
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(4000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }).start();
        
        this.id = id;
        this.name = name;
        System.out.println(name+"生产完毕");
    }
}

Future()

public class Future {

    private  Product product;

    private boolean down;//蛋糕是否完成了

    public synchronized void setProduct(Product product) {
        if (down){
            return;
        }

        this.product = product;
        this.down = true;
        notifyAll();
    }

    public  synchronized Product getProduct() {
        while (!down){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return product;
    }

}

 

Main()

public class Demo {


    public static void main(String[] args) {
        ProductFactory pf = new ProductFactory();
        Future f = pf.createProduct("蛋糕");

        System.out.println("去上班，下班取蛋糕");
        System.out.println("拿着蛋糕回家"+f.getProduct());

    }
}

 

Console:

下单成功了，可以去上班了...
去上班，下班取蛋糕
开始生产...蛋糕
蛋糕生产完毕
拿着蛋糕回家Product{id=-742988975, name='蛋糕'}

 

 

 

完