深入源码解析！带你零基础认识和分析学习相关的异步任务提交机制FutureTask的底层原理

最新推荐文章于 2024-09-27 14:31:57 发布
最新推荐文章于 2024-09-27 14:31:57 发布
阅读量273 收藏 2
点赞数 1
文章标签： java 后端 tomcat
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wdj_yyds/article/details/132344361
版权

FutureTask的基本介绍

FutureTask是Java中的一个类，它实现了Future接口和Runnable接口，并且被用作线程执行的任务。FutureTask可以在多线程环境下异步执行一个任务并获取其结果。

FutureTask的特点用法

  1. 异步执行：通过将耗时的任务交给FutureTask，在一个单独的线程中执行，当前线程可以继续执行其他任务，不会被阻塞，从而提高程序的并发性。

  2. 获取结果：FutureTask提供了get()方法，用于在任务完成后获取其执行结果。如果任务尚未完成，get()方法将阻塞当前线程，直到任务完成并返回结果。

  3. 取消任务：可以使用cancel()方法取消任务的执行。如果任务尚未开始执行，则会取消任务的执行；如果任务已经开始执行，则根据传入的参数决定是否中断正在执行的任务。

  4. 线程安全：FutureTask是线程安全的，可以在多个线程中共享使用。多个线程可以同时调用FutureTask的get()方法等待任务结果。

FutureTask常见的应用场景是在并发编程中，将计算密集型的任务交给FutureTask后台执行，并在需要时获取结果。这样可以充分利用系统资源，提高程序的性能和响应能力。

FutureTask的执行流程

在这里插入图片描述

任务提交

在之前的线程池分析中，我们介绍了AbstractExecutorService的实现。AbstractExecutorService是Java中的一个抽象类，它实现了ExecutorService接口，并提供了一些通用的逻辑和方法来简化线程池的实现。

AbstractExecutorService的主要特点和用法

  1. 线程池管理：AbstractExecutorService提供了默认的线程池管理逻辑。我们可以通过继承AbstractExecutorService并实现其中的抽象方法来定制自己的线程池。

  2. 任务执行：通过调用submit()或invokeAll()等方法，可以将任务提交给AbstractExecutorService来执行。它会在适当的时候自动创建线程并执行任务。

  3. 异常处理：AbstractExecutorService提供了一些默认的异常处理机制，比如可以捕获任务执行过程中抛出的异常，并进行相应的处理操作。我们也可以在继承AbstractExecutorService时自定义异常处理逻辑。

  4. 生命周期管理：AbstractExecutorService定义了线程池的生命周期方法，如shutdown()和isShutdown()等，用于管理线程池的启动和关闭。

对象模型转换传递流程

在这里插入图片描述

submit方法提交任务

AbstractExecutorService主要用于实现ExecutorService接口中的submit()和invokeAll()等方法。它提供了一些默认的实现，使得我们可以更方便地创建和管理线程池，并执行任务。

 

java
 

复制代码
 

public Future<?> submit(Runnable task) { if (task == null) throw new NullPointerException(); RunnableFuture<Void> ftask = newTaskFor(task, null); execute(ftask); return ftask; } public <T> Future<T> submit(Runnable task, T result) { if (task == null) throw new NullPointerException(); RunnableFuture<T> ftask = newTaskFor(task, result); execute(ftask); return ftask; } public <T> Future<T> submit(Callable<T> task) { if (task == null) throw new NullPointerException(); RunnableFuture<T> ftask = newTaskFor(task); execute(ftask); return ftask; } 
 

RunnableFuture任务模型
 

通过使用RunnableFuture，我们可以更加灵活地管理线程池，处理任务的提交和执行，并在需要时进行异常处理和线程池的关闭。最终进行构建一个FutureTask对象。
 

 

java
 

复制代码
 

protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) { return new FutureTask<T>(runnable, value); } protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) { return new FutureTask<T>(callable); } 
 

FutureTask
 

对于通过submit方法提交的任务，无论是Runnable还是Callable接口实现，都会被统一封装为FutureTask对象，并传递给execute方法。
 

 

java
 

复制代码
 

public FutureTask(Callable<V> callable) { if (callable == null) throw new NullPointerException(); this.callable = callable; this.state = NEW; // 确保 callable 的可见性 } public FutureTask(Runnable runnable, V result) { this.callable = Executors.callable(runnable, result); this.state = NEW; // 确保可调用的可见性 } 
 

 
 
注意，AbstractExecutorService是一个抽象类，不能直接实例化。我们可以继承AbstractExecutorService类并实现其中的抽象方法，或者使用Java提供的具体实现类如ThreadPoolExecutor来创建并使用线程池。
 

 

RunnableAdapter适配器模型
 

RunnableAdapter的作用是将一个Runnable对象包装成一个Callable对象。在适配器的call()方法中，会调用任务的run()方法来执行任务，并返回预先指定的结果。
 

 

java
 

复制代码
 

public static <T> Callable<T> callable(Runnable task, T result) { if (task == null) throw new NullPointerException(); return new RunnableAdapter<T>(task, result); } 
 

通过使用RunnableAdapter，我们可以将Runnable任务在提交给ExecutorService时，以Callable的方式进行处理和执行。
 

 

java
 

复制代码
 

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

该适配器的设计使得我们可以更加方便地将Runnable任务与Callable任务一同处理，充分利用ExecutorService的统一接口，并且无需对Runnable任务进行额外的修改。
 

任务状态
 

FutureTask的状态定义，说明了FutureTask对象可能处于的不同状态。初始状态为NEW，后续可能会演化为COMPLETING、NORMAL、EXCEPTIONAL、CANCELLED、INTERRUPTING、INTERRUPTED等状态。
 

 

java
 

复制代码
 

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; 
 

 

在这里插入图片描述
 

这些状态描述了FutureTask在执行过程中的不同情况，包括正常完成、遇到异常、被取消、被中断等。了解FutureTask的状态有助于我们理解和处理FutureTask对象在多线程环境下的行为。
 

任务执行
 

首先，方法会检查FutureTask的状态是否为NEW，并尝试使用compareAndSwapObject方法将执行线程设置为当前线程。然后，方法将执行并处理相关任务，并根据任务是否成功完成设置相应的结果。最后，清除执行线程(runner)并重新获取FutureTask的状态，根据状态处理可能的取消操作。
 

 

java
 

复制代码
 

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非空直到state被稳定设置，以防止并发调用run() runner = null; // 在将runner设置为空之后必须重新读取state以防止泄漏中断 int s = state; if (s >= INTERRUPTING) { handlePossibleCancellationInterrupt(s); } } } 
 

 

在这里插入图片描述
 

设置线程任务数据结果
 

对于Callable对象，FutureTask会直接执行它的call方法。如果call方法执行成功，FutureTask会调用set方法来设置执行结果；如果遇到异常，FutureTask会调用setException方法来设置异常。
 

 

java
 

复制代码
 

protected void set(V v) { // 首先使用CAS（比较并交换）将状态设置为中间状态COMPLETING if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) { outcome = v; // 将状态设置为正常状态 UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // 最终状态 finishCompletion(); } } protected void setException(Throwable t) { if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) { outcome = t; // 将状态设置为异常状态 UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // 最终状态 finishCompletion(); } } 
 

下面是对于Callable直接执行其call方法的处理过程。
 

在这里插入图片描述
 

  1. 通过CAS操作将FutureTask的状态设置为中间状态COMPLETING。
  2. 根据执行的结果（成功或异常），将结果或异常存储在outcome变量中，并将状态设置为相应的最终状态（正常状态或异常状态）。
  3. 完成执行并处理相关的完成操作。
 

获取线程任务数据结果
 

下面的这两个方法都是用来对全局变量outcome进行赋值的。而当我们通过get方法在另一个线程中获取结果时，将会执行以下过程：
 

 

java
 

复制代码
 

public V get() throws InterruptedException, ExecutionException { int s = state; if (s <= COMPLETING) s = awaitDone(false, 0L); return report(s); } 
 

如果任务尚未完成，则会等待任务完成：
 

 

java
 

复制代码
 

private int awaitDone(boolean timed, long nanos) throws InterruptedException { final long deadline = timed ? System.nanoTime() + nanos : 0L; WaitNode q = null; boolean queued = false; // 使用for循环阻塞当前线程 for (;;) { // 响应中断 if (Thread.interrupted()) { removeWaiter(q); throw new InterruptedException(); } int s = state; // 任务已经完成或者已经抛出异常，直接返回 if (s > COMPLETING) { // WaitNode已经创建，当前可以设置为null了 if (q != null) q.thread = null; return s; } else if (s == COMPLETING) // 不能超时 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); } } 
 

下面是我们通过get方法在另一个线程中获取结果的过程。
 

在这里插入图片描述
 

  1. 首先，通过调用get方法获取FutureTask的状态值。
  2. 如果状态值小于或等于COMPLETING，则调用awaitDone方法来等待任务的完成。
  3. 在awaitDone方法中，根据是否设置了超时时间计算出等待的截止时间，并使用for循环来阻塞当前线程。
  4. 在循环中，对中断请求进行响应，并检查任务的状态。
  5. 如果设置了超时时间，则根据剩余的等待时间使用LockSupport.parkNanos进行阻塞。
  6. 如果没有设置超时时间，则使用LockSupport.park进行阻塞。
  7. 循环会一直执行，直到任务完成或超时，才会返回任务的状态值。
  8. 最后，通过调用report方法来返回相应的结果。 总之，该过程描述了在另一个线程中通过get方法等待任务完成的过程。它通过阻塞当前线程并监测任务状态来实现等待，直到任务完成后才返回结果。
 

上报线程任务数据结果
 

如果任务已完成或者等待任务直到完成后，将会调用report方法来返回结果， report 方法，发现状态为异常的话将包装成 ExecutionException((Throwable)x); 这个异常就是我们在使用 get 的时候需要捕获的异常。
 

 

java
 

复制代码
 

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

如果状态s等于NORMAL，表示任务正常完成，将会返回实际的结果。如果状态s大于等于CANCELLED，则抛出CancellationException异常。否则，抛出ExecutionException异常。通过这样的设计，无论是任务正常完成还是抛出异常，都能够在线程池中执行的任务中被感知到。
 

任务取消
 

通过调用cancel方法可以取消FutureTask的执行，并在任务完成后通过finishCompletion方法来唤醒等待的线程。被唤醒的线程在awaitDone方法中继续循环，检查任务的状态以获取结果。
 

 

java
 

复制代码
 

public boolean cancel(boolean mayInterruptIfRunning) { // 如果任务不是刚创建或者是刚创建但是更改为指定状态失败则返回 false 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; } 
 

  1. FutureTask类中有一个cancel方法，接受一个布尔类型参数mayInterruptIfRunning，用于表示在执行中的任务是否可以中断。
  2. cancel方法首先检查任务的状态，如果状态不是NEW或者尝试将状态更改为INTERRUPTING或CANCELLED失败，则返回false。
  3. 如果允许中断正在运行的任务（mayInterruptIfRunning为true），则调用Thread的interrupt方法来中断任务的线程，并将任务的状态设置为INTERRUPTED。
  4. 然后，调用finishCompletion方法来完成任务的完成操作。
  5. 在finishCompletion方法中，首先尝试将waiters设置为null，以便其他线程无法再加入等待队列。然后循环遍历等待队列，唤醒等待的线程，并将等待队列中节点的thread属性设置为null。
  6. 在唤醒线程后，被唤醒的线程会在awaitDone方法中继续循环，检查任务的状态。
  7. 如果任务的状态大于COMPLETING，则表示任务已完成或抛出异常，直接返回状态。
 

总结说明
 

  •  
    FutureTask是一个用于异步执行任务并获取结果的Java类。它提供了获取结果、取消任务等功能，帮助我们更好地处理多线程编程中的任务执行和结果获取。
     
  •  
    AbstractExecutorService是Java中用于简化线程池实现的一个抽象类。通过继承并实现其中的方法，我们可以更方便地管理线程池的创建、任务的提交和执行。它提供了默认的异常处理和生命周期管理，并可以根据需要进行定制和扩展。
     

                

        

        

        

    

  


    

      

        

            

              
                
                  Java爱好狂.
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
【java】java 多线程 异步计算 FutureTask 源码详解

				
			

			

				

					九师兄
				

				

					03-19
					
					1052
					
				

			

		

		

			
				
FutureTask 为 Future 提供了基础实现，如获取任务执行结果(get)和取消任务(cancel)等。如果任务尚未完成，获取任务执行结果时将会阻塞。一旦执行结束，任务就不能被重启或取消(除非使用runAndReset执行计算)。FutureTask 常用来封装 Callable 和 Runnable，也可以作为一个任务提交到线程池中执行。除了作为一个独立的类之外，此类也提供了一些功能性函数供我们创建自定义 task 类使用。FutureTask 的线程安全由CAS来保证。

			
		

	



                

            
              



	

		

			

				
					
【并发】深入理解Java线程的底层原理

				
			

			

				

					金鳞踏雨
				

				

					11-29
					
					1014
					
				

			

		

		

			
				
操作系统会以进程为单位，分配系统资源（CPU时间片、内存等资源），进程是资源分配的最小单位。线程，有时被称为轻量级进程，是操作系统调度（CPU调度）执行的最小单位。Java 语言中线程共有六种状态，分别是：
NEW（初始化状态）
RUNNABLE（可运行状态+运行状态）
BLOCKED（阻塞状态）
WAITING（无时限等待）
TIMED_WAITING（有时限等待）
TERMINATED（终止状态）

			
		

	



              


  
              

                


	

		

			

				
					
FutureTask 原理剖析

				
			

			

				

					luoxn28的专栏
				

				

					10-28
					
					1073
					
				

			

		

		

			
				
戳蓝字「TopCoder」关注我们哦！编者注：FutureTask用于在异步操作场景中，FutureTask作为生产者(执行FutureTask的线程)和消费者(获取FutureTask...

			
		

	





	

		

			

				
					
Future、FutureTask实现原理浅析(源码解读)

				
			

			

				

					weixin_33910759的博客
				

				

					12-20
					
					720
					
				

			

		

		

			
				
前言
最近一直在看JUC下面的一些东西，发现很多东西都是以前用过，但是真是到原理层面自己还是很欠缺。
刚好趁这段时间不太忙，回来了便一点点学习总结。
前言
最近一直在看JUC下面的一些东西，发现很多东西都是以前用过，但是真是到原理层面自己还是很欠缺。
刚好趁这段时间不太忙，回来了便一点点学习总结。
由于自己水平有限，可能存在大量漏洞和思考不周到的地方，不吝赐教。
Future 模式
一种非常经典的...

			
		

	



		

			
		



	

		

			

				
					
【FutureTask】FutureTask原理

					
最新发布

				
			

			

				

					m0_64944491的博客
				

				

					09-27
					
					579
					
				

			

		

		

			
				
Future<?});Future 位于 java.util.concurrent 包下，是异步任务的顶层接口。

			
		

	





	

		

			

				
					
FutureTask原理及源码分析

				
			

			

				

					雪蓑的博客
				

				

					07-01
					
					445
					
				

			

		

		

			
				
清简介：

FutureTask 是一个可取消的、可获得执行结果异步任务，通过线程池ExecutorService 来执行FutureTask。

FutureTask类 实现了RunnableFuture接口，而RunnableFuture 继承了Runnable和Future接口，所以本质上 FutureTask是Runnable的一种实现。

我们先来一张工作原理图：





总之：同一时间，N个线程争抢一个FutureTask，只有一个线程（比如A）...

			
		

	





	

		

			

				
					
FutureTask 原理

				
			

			

				

					加多的博客
				

				

					01-19
					
					453
					
				

			

		

		

			
				
二十、FutureTask 原理20.1 一个例子    static class Task implements CallableInteger> {
        @Override
        public Integer call() throws Exception {
            System.out.println("子线程在进行计算");
            

			
		

	





	

		

			

				
					
Java线程池源码深度解析

				
			

			

				

					知识分享官
				

				

					10-23
					
					1175
					
				

			

		

		

			
				
本文主要从源码层面分析了线程池的运行机理，总算知道了execute方法背后是如何运转的。

			
		

	





	

		

			

				
					
【JUC】Callable底层源码分析

				
			

			

				

					aaa_bbb_ccc_123_456的博客
				

				

					12-25
					
					2990
					
				

			

		

		

			
				
1.线程创建

我们创建线程一般有以下几种方式：


1,承Thread，重写run方法


2,实现Runnable接口，重新run方法


3,实现Callable接口并重写call方法。


我们今天聊的就是第三种。实现Callable接口并重写call方法，与 Runnable 相比Callable又有些不同：


1, Callable 可以在任务结束的时候提供一个返回值，Runnabl...

			
		

	





	

		

			

				
					
【Android面试八股文】你能说一说AsyncTask的原理吗？

				
			

			

				

					字节卷动
				

				

					06-15
					
					78
					
				

			

		

		

			
				
AsyncTask是一个抽象类，通过继承它可以创建自己的异步任务类。AsyncTaskParams：执行任务时的输入参数类型。Progress：后台任务执行过程中的进度更新类型。Result：后台任务执行完毕后的返回结果类型。AsyncTask：在后台线程中执行任务，该方法是抽象方法，需要子类实现。：在执行后台任务之前执行，通常用于进行一些准备工作，该方法在主线程中执行。：在后台任务执行完毕后执行，接收后台任务的返回结果作为参数，该方法在主线程中执行。：在后台任务执行过程中调用。

			
		

	





	

		

			

				
					
Java线程池FutureTask实现原理详解

				
			

			

				

					08-28
				

			

		

		

			
				
主要介绍了Java线程池FutureTask实现原理详解，小编觉得还是挺不错的，具有一定借鉴价值，需要的朋友可以参考下

			
		

	





	

		

			

				
					
FutureTask原理

				
			

			

				

					Donqueer的博客
				

				

					06-19
					
					273
					
				

			

		

		

			
				
介绍
JDK future框架，提供了一种异步编程模式，基于线程池的。将任务runnable/callable提交到线程池executor，返回一个Future对象。通过future.get()获取执行结果，这里提交到线程池，后面的操作不会阻塞。future.get()获取结果会阻塞，其实也是用多线线程执行任务。
使用

future + callable

public static void main(String[] args) throws ExecutionException, Interrupt

			
		

	





	

		

			

				
					
FutureTask原理 JDK8

				
			

			

				

					AllenChan_的博客
				

				

					07-21
					
					797
					
				

			

		

		

			
				
FutureTask类是并发编程的一个代表异步计算任务类，提供异步计算任务的封装以及异步计算结果的返回。本身实现Runnable接口，可以直接提交给线程池执行。

不过更多应该是配合Callable使用，因为要用到Callable.call()返回的结果封装在自己的outcome变量。

那为什么有了Callable还要用这个类？因为它提供了获取异步计算结果的机制，如果任务没执行完会阻塞获取线程等待任务结束。省去了工程师自己管理的流程。




本文基于JDK 8源码分析。FutureTask已经不依赖A.

			
		

	





	

		

			

				
					
FutureTask实现原理

				
			

			

				

					到西伯利亚浪
				

				

					03-12
					
					736
					
				

			

		

		

			
				
提交的Runnable任务在内部统一被转换为Callable任务。查看submit方法的返回值，为一个Future，实际上这个Futrue为FutureTask实例，通过此实例，调用get方法，可以阻塞当前线程，直到任务运行完毕，返回结果。

			
		

	





	

		

			

				
					
FutrueTask原理分析

				
			

			

				

					行而不辍，未来可期 - King 
				

				

					11-25
					
					1067
					
				

			

		

		

			
				
通常一个请求分为请求-处理-返回，如果通过异步线程去完成一个任务，我们通常会选择FutureTask +Submit+ Callable()来实现获取返回值。

			
		

	





	

		

			

				
					
揭密FutureTask

				
			

			

				

					weixin_30747253的博客
				

				

					08-31
					
					200
					
				

			

		

		

			
				
Future是我们在使用java实现异步时最常用到的一个类，我们可以向线程池提交一个Callable，并通过future对象获取执行结果。本篇文章主要讲述了JUC中FutureTask中的一些实现原理。使用的jdk版本是1.7。
Future
　　Future是一个接口，它定义了5个方法：

boolean cancel(boolean mayInterruptIfRunnin...

			
		

	





	

		

			

				
					
深入解析FutureTask：异步任务执行与取消机制

				
			

			

				

					
				

			

		

		

			
				
本文将深入分析Java中的FutureTask源码，这是一个在并发编程中非常重要的组件，特别是在执行异步任务时。FutureTask的设计巧妙地结合了Runnable和Future接口，使得开发者能够方便地管理异步操作的结果获取和状态控制...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值