java多线程编程同步器Future和FutureTask解析及代码示例

publicinterfacefuture<v>future表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并获取计算的结果。计算完成后只能使用get方法来获取结果，如有必要，计算完成前可以阻塞此方法。取消则由cancel方法来执行。还提供了其他方法，以确定任务是正常完成还是被取消了。一旦计算完成，就不能再取消计算。如果为了可取消性而使用future但又不提供可用的结果，则可以声明future<?>形式类型、并返回null作为底层任务的结果。

future主要定义了5个方法：

1)booleancancel(booleanmayinterruptifrunning)：试图取消对此任务的执行。如果任务已完成、或已取消，或者由于某些其他原因而无法取消，则此尝试将失败。当调用cancel时，如果调用成功，而此任务尚未启动，则此任务将永不运行。如果任务已经启动，则mayinterruptifrunning参数确定是否应该以试图停止任务的方式来中断执行此任务的线程。此方法返回后，对isdone()的后续调用将始终返回true。如果此方法返回true，则对iscancelled()的后续调用将始终返回true。

2）booleaniscancelled()：如果在任务正常完成前将其取消，则返回true。

3）booleanisdone()：如果任务已完成，则返回true。可能由于正常终止、异常或取消而完成，在所有这些情况中，此方法都将返回true。

4）vget()throwsinterruptedexception,executionexception：如有必要，等待计算完成，然后获取其结果。

5）vget(longtimeout,timeunitunit)throwsinterruptedexception,executionexception,timeoutexception：如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）。

future<v>接口

future<v>接口是用来获取异步计算结果的，说白了就是对具体的runnable或者callable对象任务执行的结果进行获取(get()),取消(cancel()),判断是否完成等操作。我们看看future接口的源码：

public interface future<v> { 
 boolean cancel(boolean mayinterruptifrunning); 
 boolean iscancelled(); 
 boolean isdone(); 
 v get() throws interruptedexception, executionexception; 
 v get(long timeout, timeunit unit) throws interruptedexception, executionexception, timeoutexception; 
} 

方法解析：

vget()：获取异步执行的结果，如果没有结果可用，此方法会阻塞直到异步计算完成。

vget(longtimeout,timeunitunit)：获取异步执行结果，如果没有结果可用，此方法会阻塞，但是会有时间限制，如果阻塞时间超过设定的timeout时间，该方法将抛出异常。

booleanisdone()：如果任务执行结束，无论是正常结束或是中途取消还是发生异常，都返回true。

booleaniscanceller()：如果任务完成前被取消，则返回true。

booleancancel(booleanmayinterruptrunning)：如果任务还没开始，执行cancel(...)方法将返回false；如果任务已经启动，执行cancel(true)方法将以中断执行此任务线程的方式来试图停止任务，如果停止成功，返回true；当任务已经启动，执行cancel(false)方法将不会对正在执行的任务线程产生影响(让线程正常执行到完成)，此时返回false；当任务已经完成，执行cancel(...)方法将返回false。mayinterruptrunning参数表示是否中断执行中的线程。

通过方法分析我们也知道实际上future提供了3种功能：（1）能够中断执行中的任务（2）判断任务是否执行完成（3）获取任务执行完成后额结果。

但是我们必须明白future只是一个接口，我们无法直接创建对象，因此就需要其实现类futuretask登场啦。

futuretask类

futuretask可用于异步获取执行结果或取消执行任务的场景。通过传入runnable或者callable的任务给futuretask，直接调用其run方法或者放入线程池执行，之后可以在外部通过futuretask的get方法异步获取执行结果，因此，futuretask非常适合用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。另外，futuretask还可以确保即使调用了多次run方法，它都只会执行一次runnable或者callable任务，或者通过cancel取消futuretask的执行等。

我们来看看futuretask的实现

public class futuretask<v> implements runnablefuture<v> { 

futuretask类实现了runnablefuture接口，我们看一下runnablefuture接口的实现：

public interface runnablefuture<v> extends runnable, future<v> { 
 void run(); 
} 

分析：futuretask除了实现了future接口外还实现了runnable接口，因此futuretask也可以直接提交给executor执行。当然也可以调用线程直接执行（futuretask.run()）。接下来我们根据futuretask.run()的执行时机来分析其所处的3种状态：

（1）未启动，futuretask.run()方法还没有被执行之前，futuretask处于未启动状态，当创建一个futuretask，而且没有执行futuretask.run()方法前，这个futuretask也处于未启动状态。

（2）已启动，futuretask.run()被执行的过程中，futuretask处于已启动状态。

（3）已完成，futuretask.run()方法执行完正常结束，或者被取消或者抛出异常而结束，futuretask都处于完成状态。

futuretask类是future的一个实现，并实现了runnable，所以可通过excutor(线程池)来执行。也可传递给thread对象执行。如果在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给future对象在后台完成，当主线程将来需要时，就可以通过future对象获得后台作业的计算结果或者执行状态。下面的例子模拟一个会计算账的过程，主线程已经获得其他帐户的总额了，为了不让主线程等待privateaccount类的计算结果的返回而启用新的线程去处理，并使用futuretask对象来监控，这样，主线程还可以继续做其他事情，最后需要计算总额的时候再尝试去获得privateaccount的信息。

package test;
import java.util.random;
import java.util.concurrent.callable;
import java.util.concurrent.executionexception;
import java.util.concurrent.futuretask;
/**
 *
 * @author administrator
 *
 */
@suppresswarnings("all")
public class futuretaskdemo {
	public static void main(string[] args) {
		// 初始化一个callable对象和futuretask对象
		callable paccount = new privateaccount();
		futuretask futuretask = new futuretask(paccount);
		// 使用futuretask创建一个线程
		thread paccountthread = new thread(futuretask);
		system.out.println("futuretask线程现在开始启动，启动时间为：" + system.nanotime());
		paccountthread.start();
		system.out.println("主线程开始执行其他任务");
		// 从其他账户获取总金额
		int totalmoney = new random().nextint(100000);
		system.out.println("现在你在其他账户中的总金额为" + totalmoney);
		system.out.println("等待私有账户总金额统计完毕...");
		// 测试后台的计算线程是否完成，如果未完成则等待
		while (!futuretask.isdone()) {
			try {
				thread.sleep(500);
				system.out.println("私有账户计算未完成继续等待...");
			}
			catch (interruptedexception e) {
				e.printstacktrace();
			}
		}
		system.out.println("futuretask线程计算完毕，此时时间为" + system.nanotime());
		integer privateaccountmoney = null;
		try {
			privateaccountmoney = (integer) futuretask.get();
		}
		catch (interruptedexception e) {
			e.printstacktrace();
		}
		catch (executionexception e) {
			e.printstacktrace();
		}
		system.out.println("您现在的总金额为：" + totalmoney + privateaccountmoney.intvalue());
	}
}
@suppresswarnings("all")
class privateaccount implements callable {
	integer totalmoney;
	@override
		public object call() throws exception {
		thread.sleep(5000);
		totalmoney = new integer(new random().nextint(10000));
		system.out.println("您当前有" + totalmoney + "在您的私有账户中");
		return totalmoney;
	}
}

运行结果 

futuretask线程现在开始启动，启动时间为：3098040622063 
主线程开始执行其他任务 
现在你在其他账户中的总金额为56983 
等待私有账户总金额统计完毕... 
私有账户计算未完成继续等待... 
私有账户计算未完成继续等待... 
私有账户计算未完成继续等待... 
私有账户计算未完成继续等待... 
私有账户计算未完成继续等待... 
私有账户计算未完成继续等待... 
私有账户计算未完成继续等待... 
私有账户计算未完成继续等待... 
私有账户计算未完成继续等待... 
您当前有3345在您的私有账户中 
私有账户计算未完成继续等待... 
futuretask线程计算完毕，此时时间为3103072404138 
您现在的总金额为：569833345

总结

以上就是本文关于java多线程编程同步器future和futuretask解析及代码示例的全部内容，希望对大家有所帮助。感兴趣的朋友可以继续参阅本站：

java多线程之显示锁和内置锁总结详解

java多线程中断机制三种方法及示例

如有不足之处，欢迎留言指出。