从源码角度详解Java的Callable接口

摘要：本文从源码角度深刻解析Callable接口。

本文分享自华为云社区《深刻解析Callable接口》，做者：冰河。java

本文纯干货，从源码角度深刻解析Callable接口，但愿你们踏下心来，打开你的IDE，跟着文章看源码，相信你必定收获不小。缓存

1.Callable接口介绍

Callable接口是JDK1.5新增的泛型接口，在JDK1.8中，被声明为函数式接口，以下所示。安全

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

在JDK 1.8中只声明有一个方法的接口为函数式接口，函数式接口能够使用@FunctionalInterface注解修饰，也能够不使用@FunctionalInterface注解修饰。只要一个接口中只包含有一个方法，那么，这个接口就是函数式接口。ide

在JDK中，实现Callable接口的子类以下图所示。函数

默认的子类层级关系图看不清，这里，能够经过IDEA右键Callable接口，选择“Layout”来指定Callable接口的实现类图的不一样结构，以下所示。this

这里，能够选择“Organic Layout”选项，选择后的Callable接口的子类的结构以下图所示。url

在实现Callable接口的子类中，有几个比较重要的类，以下图所示。spa

分别是：Executors类中的静态内部类：PrivilegedCallable、PrivilegedCallableUsingCurrentClassLoader、RunnableAdapter和Task类下的TaskCallable。.net

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);
	}
}

好了，今天就到这儿吧，我是冰河，咱们下期见~~

点击关注，第一时间了解华为云新鲜技术~