高並發之——深入解析Callable接口

本文純干貨，從源碼角度深入解析Callable接口，希望大家踏下心來，打開你的IDE，跟着文章看源碼，相信你一定收獲不小。

1.Callable接口介紹

Callable接口是JDK1.5新增的泛型接口，在JDK1.8中，被聲明為函數式接口，如下所示。

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

在JDK 1.8中只聲明有一個方法的接口為函數式接口，函數式接口可以使用@FunctionalInterface注解修飾，也可以不使用@FunctionalInterface注解修飾。只要一個接口中只包含有一個方法，那么，這個接口就是函數式接口。

在JDK中，實現Callable接口的子類如下圖所示。

這里，可以通過IDEA右鍵Callable接口，選擇“Layout”來指定Callable接口的實現類圖的不同結構，如下所示。

這里，可以選擇“Organic Layout”選項，選擇后的Callable接口的子類的結構如下圖所示。

在實現Callable接口的子類中，有幾個比較重要的類，如下圖所示。

分別是：Executors類中的靜態內部類：PrivilegedCallable、PrivilegedCallableUsingCurrentClassLoader、RunnableAdapter和Task類下的TaskCallable。

2.實現Callable接口的重要類分析

接下來，分析的類主要有：PrivilegedCallable、PrivilegedCallableUsingCurrentClassLoader、RunnableAdapter和Task類下的TaskCallable。雖然這些類在實際工作中很少被直接用到，但是作為一名合格的開發工程師，設置是禿頂的資深專家來說，了解並掌握這些類的實現有助你進一步理解Callable接口，並提高專業技能（頭發再掉一批，哇哈哈哈。。。）。

• PrivilegedCallable

PrivilegedCallable類是Callable接口的一個特殊實現類，它表明Callable對象有某種特權來訪問系統的某種資源，PrivilegedCallable類的源代碼如下所示。

/**
 * A callable that runs under established access control settings
 */
static final class PrivilegedCallable<T> implements Callable<T> {
    private final Callable<T> task;
    private final AccessControlContext acc;

    PrivilegedCallable(Callable<T> task) {
        this.task = task;
        this.acc = AccessController.getContext();
    }

    public T call() throws Exception {
        try {
            return AccessController.doPrivileged(
                new PrivilegedExceptionAction<T>() {
                    public T run() throws Exception {
                        return task.call();
                    }
                }, acc);
        } catch (PrivilegedActionException e) {
            throw e.getException();
        }
    }
}

從PrivilegedCallable類的源代碼來看，可以將PrivilegedCallable看成是對Callable接口的封裝，並且這個類也繼承了Callable接口。

在PrivilegedCallable類中有兩個成員變量，分別是Callable接口的實例對象和AccessControlContext類的實例對象，如下所示。

private final Callable<T> task;
private final AccessControlContext acc;

其中，AccessControlContext類可以理解為一個具有系統資源訪問決策的上下文類，通過這個類可以訪問系統的特定資源。通過類的構造方法可以看出，在實例化AccessControlContext類的對象時，只需要傳遞Callable接口子類的對象即可，如下所示。

PrivilegedCallable(Callable<T> task) {
    this.task = task;
    this.acc = AccessController.getContext();
}

AccessControlContext類的對象是通過AccessController類的getContext()方法獲取的，這里，查看AccessController類的getContext()方法，如下所示。

public static AccessControlContext getContext(){
    AccessControlContext acc = getStackAccessControlContext();
    if (acc == null) {
        return new AccessControlContext(null, true);
    } else {
        return acc.optimize();
    }
}

通過AccessController的getContext()方法可以看出，首先通過getStackAccessControlContext()方法來獲取AccessControlContext對象實例。如果獲取的AccessControlContext對象實例為空，則通過調用AccessControlContext類的構造方法實例化，否則，調用AccessControlContext對象實例的optimize()方法返回AccessControlContext對象實例。

這里，我們先看下getStackAccessControlContext()方法是個什么鬼。

private static native AccessControlContext getStackAccessControlContext();

原來是個本地方法，方法的字面意思就是獲取能夠訪問系統棧的決策上下文對象。

接下來，我們回到PrivilegedCallable類的call()方法，如下所示。

public T call() throws Exception {
    try {
        return AccessController.doPrivileged(
            new PrivilegedExceptionAction<T>() {
                public T run() throws Exception {
                    return task.call();
                }
            }, acc);
    } catch (PrivilegedActionException e) {
        throw e.getException();
    }
}

通過調用AccessController.doPrivileged()方法，傳遞PrivilegedExceptionAction。接口對象和AccessControlContext對象，並最終返回泛型的實例對象。

首先，看下AccessController.doPrivileged()方法，如下所示。

@CallerSensitive
public static native <T> T
    doPrivileged(PrivilegedExceptionAction<T> action,
                 AccessControlContext context)
    throws PrivilegedActionException;

可以看到，又是一個本地方法。也就是說，最終的執行情況是將PrivilegedExceptionAction接口對象和AccessControlContext對象實例傳遞給這個本地方法執行。並且在PrivilegedExceptionAction接口對象的run()方法中調用Callable接口的call()方法來執行最終的業務邏輯，並且返回泛型對象。

•  PrivilegedCallableUsingCurrentClassLoader

此類表示為在已經建立的特定訪問控制和當前的類加載器下運行的Callable類，源代碼如下所示。

/**
 * A callable that runs under established access control settings and
 * current ClassLoader
 */
static final class PrivilegedCallableUsingCurrentClassLoader<T> implements Callable<T> {
    private final Callable<T> task;
    private final AccessControlContext acc;
    private final ClassLoader ccl;

    PrivilegedCallableUsingCurrentClassLoader(Callable<T> task) {
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
            sm.checkPermission(new RuntimePermission("setContextClassLoader"));
        }
        this.task = task;
        this.acc = AccessController.getContext();
        this.ccl = Thread.currentThread().getContextClassLoader();
    }

    public T call() throws Exception {
        try {
            return AccessController.doPrivileged(
                new PrivilegedExceptionAction<T>() {
                    public T run() throws Exception {
                        Thread t = Thread.currentThread();
                        ClassLoader cl = t.getContextClassLoader();
                        if (ccl == cl) {
                            return task.call();
                        } else {
                            t.setContextClassLoader(ccl);
                            try {
                                return task.call();
                            } finally {
                                t.setContextClassLoader(cl);
                            }
                        }
                    }
                }, acc);
        } catch (PrivilegedActionException e) {
            throw e.getException();
        }
    }
}

這個類理解起來比較簡單，首先，在類中定義了三個成員變量，如下所示。

private final Callable<T> task;
private final AccessControlContext acc;
private final ClassLoader ccl;

接下來，通過構造方法注入Callable對象，在構造方法中，首先獲取系統安全管理器對象實例，通過系統安全管理器對象實例檢查是否具有獲取ClassLoader和設置ContextClassLoader的權限。並在構造方法中為三個成員變量賦值，如下所示。

PrivilegedCallableUsingCurrentClassLoader(Callable<T> task) {
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
        sm.checkPermission(new RuntimePermission("setContextClassLoader"));
    }
    this.task = task;
    this.acc = AccessController.getContext();
    this.ccl = Thread.currentThread().getContextClassLoader();
}

接下來，通過調用call()方法來執行具體的業務邏輯，如下所示。

public T call() throws Exception {
    try {
        return AccessController.doPrivileged(
            new PrivilegedExceptionAction<T>() {
                public T run() throws Exception {
                    Thread t = Thread.currentThread();
                    ClassLoader cl = t.getContextClassLoader();
                    if (ccl == cl) {
                        return task.call();
                    } else {
                        t.setContextClassLoader(ccl);
                        try {
                            return task.call();
                        } finally {
                            t.setContextClassLoader(cl);
                        }
                    }
                }
            }, acc);
    } catch (PrivilegedActionException e) {
        throw e.getException();
    }
}

在call()方法中同樣是通過調用AccessController類的本地方法doPrivileged，傳遞PrivilegedExceptionAction接口的實例對象和AccessControlContext類的對象實例。

具體執行邏輯為：在PrivilegedExceptionAction對象的run()方法中獲取當前線程的ContextClassLoader對象，如果在構造方法中獲取的ClassLoader對象與此處的ContextClassLoader對象是同一個對象（不止對象實例相同，而且內存地址也相同），則直接調用Callable對象的call()方法返回結果。否則，將PrivilegedExceptionAction對象的run()方法中的當前線程的ContextClassLoader設置為在構造方法中獲取的類加載器對象，接下來，再調用Callable對象的call()方法返回結果。最終將當前線程的ContextClassLoader重置為之前的ContextClassLoader。

• RunnableAdapter

RunnableAdapter類比較簡單，給定運行的任務和結果，運行給定的任務並返回給定的結果，源代碼如下所示。

/**
 * A callable that runs given task and returns given result
 */
static final class RunnableAdapter<T> implements Callable<T> {
    final Runnable task;
    final T result;
    RunnableAdapter(Runnable task, T result) {
        this.task = task;
        this.result = result;
    }
    public T call() {
        task.run();
        return result;
    }
}

• TaskCallable

TaskCallable類是javafx.concurrent.Task類的靜態內部類，TaskCallable類主要是實現了Callable接口並且被定義為FutureTask的類，並且在這個類中允許我們攔截call()方法來更新task任務的狀態。源代碼如下所示。

private static final class TaskCallable<V> implements Callable<V> {

    private Task<V> task;
    private TaskCallable() { }

    @Override 
    public V call() throws Exception {
        task.started = true;
        task.runLater(() -> {
            task.setState(State.SCHEDULED);
            task.setState(State.RUNNING);
        });
        try {
            final V result = task.call();
            if (!task.isCancelled()) {
                task.runLater(() -> {
                    task.updateValue(result);
                    task.setState(State.SUCCEEDED);
                });
                return result;
            } else {
                return null;
            }
        } catch (final Throwable th) {
            task.runLater(() -> {
                task._setException(th);
                task.setState(State.FAILED);
            });
            if (th instanceof Exception) {
                throw (Exception) th;
            } else {
                throw new Exception(th);
            }
        }
    }
}

從TaskCallable類的源代碼可以看出，只定義了一個Task類型的成員變量。下面主要分析TaskCallable類的call()方法。

當程序的執行進入到call()方法時，首先將task對象的started屬性設置為true，表示任務已經開始，並且將任務的狀態依次設置為State.SCHEDULED和State.RUNNING，依次觸發任務的調度事件和運行事件。如下所示。

task.started = true;
task.runLater(() -> {
    task.setState(State.SCHEDULED);
    task.setState(State.RUNNING);
});

接下來，在try代碼塊中執行Task對象的call()方法，返回泛型對象。如果任務沒有被取消，則更新任務的緩存，將調用call()方法返回的泛型對象綁定到Task對象中的ObjectProperty<V>對象中，其中，ObjectProperty<V>在Task類中的定義如下。

private final ObjectProperty<V> value = new SimpleObjectProperty<>(this, "value");

接下來，將任務的狀態設置為成功狀態。如下所示。

try {
    final V result = task.call();
    if (!task.isCancelled()) {
        task.runLater(() -> {
            task.updateValue(result);
            task.setState(State.SUCCEEDED);
        });
        return result;
    } else {
        return null;
    }
}

如果程序拋出了異常或者錯誤，會進入catch()代碼塊，設置Task對象的Exception信息並將狀態設置為State.FAILED，也就是將任務標記為失敗。接下來，判斷異常或錯誤的類型，如果是Exception類型的異常，則直接強轉為Exception類型的異常並拋出。否則，將異常或者錯誤封裝為Exception對象並拋出，如下所示。

catch (final Throwable th) {
    task.runLater(() -> {
        task._setException(th);
        task.setState(State.FAILED);
    });
    if (th instanceof Exception) {
        throw (Exception) th;
    } else {
        throw new Exception(th);
    }
}

 

記住：你比別人強的地方，不是你做過多少年的CRUD工作，而是你比別人掌握了更多深入的技能。不要總停留在CRUD的表面工作，理解並掌握底層原理並熟悉源碼實現，並形成自己的抽象思維能力，做到靈活運用，才是你突破瓶頸，脫穎而出的重要方向！

最后，作為一名合格（發際線比較高）的開發人員或者資深（禿頂）的工程師和架構師來說，理解原理和掌握源碼，並形成自己的抽象思維能力，靈活運用是你必須掌握的技能。

 

掃一掃關注冰河技術微信公眾號，每天推送技術干貨