课外小发现



Summary：

• public class FutureTask<V> implements RunnableFuture<V>
• 对Future、Runnable、Callable接口的整合和实现

Fields：

[java] view plain copy print?

1. private Callable<V> callable;  
2. private volatile int state;  
3.     private static final int NEW          = 0;  
4.     private static final int COMPLETING   = 1;  
5.     private static final int NORMAL       = 2;  
6.     private static final int EXCEPTIONAL  = 3;  
7.     private static final int CANCELLED    = 4;  
8.     private static final int INTERRUPTING = 5;  
9.     private static final int INTERRUPTED  = 6;  
10. private Object outcome;   
11. private volatile Thread runner; /** The thread running the callable; CASed during run() */  
12. private volatile WaitNode waiters;  

private Callable<V> callable;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;private Object outcome; private volatile Thread runner; /** The thread running the callable; CASed during run() */private volatile WaitNode waiters;

Constructor：

[java] view plain copy print?

1. public FutureTask(Callable<V> callable) {  
2.         if (callable == null)  
3.             throw new NullPointerException();  
4.         this.callable = callable;  
5.         this.state = NEW;       // ensure visibility of callable  
6. }  
7. public FutureTask(Runnable runnable, V result) {  
8.         this.callable = Executors.callable(runnable, result);  
9.         this.state = NEW;       // ensure visibility of callable  
10. }  

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

run

[java] view plain copy print?

1. public void run() {  
2.         if (state != NEW ||  
3.             !UNSAFE.compareAndSwapObject(this, runnerOffset,null, Thread.currentThread()))  
4.             return;  
5.         try {  
6.             Callable<V> c = callable;  
7.             if (c != null && state == NEW) {  
8.                 V result;  
9.                 boolean ran;  
10.                 try {  
11.                     result = c.call();  
12.                     ran = true;  
13.                 } catch (Throwable ex) {  
14.                     result = null;  
15.                     ran = false;  
16.                     setException(ex);  
17.                 }  
18.                 if (ran)  
19.                     set(result);  
20.             }  
21.         } finally {  
22.             runner = null;  
23.             int s = state;  
24.             if (s >= INTERRUPTING)  
25.                 handlePossibleCancellationInterrupt(s);  
26.         }  
27. }  
28.   
29. protected void set(V v) {  
30.         if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {  
31.             outcome = v;  
32.             UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state  
33.             finishCompletion();  
34.         }  
35. }  

public void run() {        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);                }                if (ran)                    set(result);            }        } finally {            runner = null;            int s = state;            if (s >= INTERRUPTING)                handlePossibleCancellationInterrupt(s);        }}protected void set(V v) {        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {            outcome = v;            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state            finishCompletion();        }}

isCancelled()

[java] view plain copy print?

1. public boolean isCancelled() {  
2.         return state >= CANCELLED;  
3. }  

public boolean isCancelled() {        return state >= CANCELLED;}

isDone()

[java] view plain copy print?

1. public boolean isDone() {  
2.         return state != NEW;  
3. }  

public boolean isDone() {        return state != NEW;}

get:

[java] view plain copy print?

1. public V get() throws InterruptedException, ExecutionException {  
2.         int s = state;  
3.         if (s <= COMPLETING)  
4.             s = awaitDone(false, 0L);  
5.         return report(s);  
6. }  
7.     private int awaitDone(boolean timed, long nanos)  
8.         throws InterruptedException {  
9.         final long deadline = timed ? System.nanoTime() + nanos : 0L;  
10.         WaitNode q = null;  
11.         boolean queued = false;  
12.         for (;;) {  
13.             if (Thread.interrupted()) {  
14.                 removeWaiter(q);  
15.                 throw new InterruptedException();  
16.             }  
17.   
18.             int s = state;  
19.             if (s > COMPLETING) {  
20.                 if (q != null)  
21.                     q.thread = null;  
22.                 return s;  
23.             }  
24.             else if (s == COMPLETING) // cannot time out yet  
25.                 Thread.yield();  
26.             else if (q == null)  
27.                 q = new WaitNode();  
28.             else if (!queued)  
29.                 queued = UNSAFE.compareAndSwapObject(this, waitersOffset,  
30.                                                      q.next = waiters, q);  
31.             else if (timed) {  
32.                 nanos = deadline - System.nanoTime();  
33.                 if (nanos <= 0L) {  
34.                     removeWaiter(q);  
35.                     return state;  
36.                 }  
37.                 LockSupport.parkNanos(this, nanos);  
38.             }  
39.             else  
40.                 LockSupport.park(this);  
41.         }  
42.     }  
43.     @SuppressWarnings("unchecked")  
44.     private V report(int s) throws ExecutionException {  
45.         Object x = outcome;  
46.         if (s == NORMAL)  
47.             return (V)x;  
48.         if (s >= CANCELLED)  
49.             throw new CancellationException();  
50.         throw new ExecutionException((Throwable)x);  
51.     }  

public V get() throws InterruptedException, ExecutionException {        int s = state;        if (s <= COMPLETING)            s = awaitDone(false, 0L);        return report(s);}    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) // 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);        }    }    @SuppressWarnings("unchecked")    private V report(int s) throws ExecutionException {        Object x = outcome;        if (s == NORMAL)            return (V)x;        if (s >= CANCELLED)            throw new CancellationException();        throw new ExecutionException((Throwable)x);    }

cancel():

[java] view plain copy print?

1. public boolean cancel(boolean mayInterruptIfRunning) {  
2.         if (!(state == NEW &&  
3.               UNSAFE.compareAndSwapInt(this, stateOffset, NEW,  
4.                   mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))  
5.             return false;  
6.         try {    // in case call to interrupt throws exception  
7.             if (mayInterruptIfRunning) {  
8.                 try {  
9.                     Thread t = runner;  
10.                     if (t != null)  
11.                         t.interrupt();  
12.                 } finally { // final state  
13.                     UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);  
14.                 }  
15.             }  
16.         } finally {  
17.             finishCompletion();  
18.         }  
19.         return true;  
20. }  

public boolean cancel(boolean mayInterruptIfRunning) {        if (!(state == NEW &&              UNSAFE.compareAndSwapInt(this, stateOffset, NEW,                  mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))            return false;        try {    // in case call to interrupt throws exception            if (mayInterruptIfRunning) {                try {                    Thread t = runner;                    if (t != null)                        t.interrupt();                } finally { // final state                    UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);                }            }        } finally {            finishCompletion();        }        return true;}

Unsafe

[java] view plain copy print?

1. // Unsafe mechanics  
2. private static final sun.misc.Unsafe UNSAFE;  
3. private static final long stateOffset;  
4. private static final long runnerOffset;  
5. private static final long waitersOffset;  
6. static {  
7.     try {  
8.         UNSAFE = sun.misc.Unsafe.getUnsafe();  
9.         Class<?> k = FutureTask.class;  
10.         stateOffset = UNSAFE.objectFieldOffset  
11.             (k.getDeclaredField("state"));  
12.         runnerOffset = UNSAFE.objectFieldOffset  
13.             (k.getDeclaredField("runner"));  
14.         waitersOffset = UNSAFE.objectFieldOffset  
15.             (k.getDeclaredField("waiters"));  
16.     } catch (Exception e) {  
17.         throw new Error(e);  
18.     }  
19. }  

    // Unsafe mechanics    private static final sun.misc.Unsafe UNSAFE;    private static final long stateOffset;    private static final long runnerOffset;    private static final long waitersOffset;    static {        try {            UNSAFE = sun.misc.Unsafe.getUnsafe();            Class<?> k = FutureTask.class;            stateOffset = UNSAFE.objectFieldOffset                (k.getDeclaredField("state"));            runnerOffset = UNSAFE.objectFieldOffset                (k.getDeclaredField("runner"));            waitersOffset = UNSAFE.objectFieldOffset                (k.getDeclaredField("waiters"));        } catch (Exception e) {            throw new Error(e);        }    }