1. Future的使用

  Future模式解决的问题是。在实际的运用场景中,可能某一个任务执行起来非常耗时,如果我们线程一直等着该任务执行完成再去执行其他的代码,就会损耗很大的性能,而Future接口就是Future的实现,它可以让当前线程将任务交给Future去执行,然后当前线程就可以去干别的事,知道耗时任务执行完成之后,当前线程直接获取结果即可。FutureTask的使用比较简单,只需要先实例化一个Callable对象,重写call方法,再创建一个FutureTask对象,将Callable对象传给FutureTask,创建一个线程,将FutureTask对象传入Thread对象,启动线程即可,接下来就直接上源码:

package com.company.thread.t5;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask; public class FutureDemo { public static void main(String[] args) { Callable<Integer> callable = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
System.out.println("正在计算结果");
Thread.sleep(3000);
return 1;
}
};
FutureTask<Integer> futureTask = new FutureTask<>(callable);
Thread thread = new Thread(futureTask);
thread.start();
//做点别的
System.out.println("干点别的");
try {
System.out.println("拿到的结果为:" + futureTask.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}

2. FutureTask源码

  FutureTask实现了RunnableFuture,而RunnableFuture同时继承了Runnable和Future接口,所以它既是一个任务,也实现了Future接口的功能。

  从上面使用的步骤来看,我们需要先实例化一个Callable对象,所以先看看Callable接口

public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}

  这是一个接口,具体的实现在重写的call方法中,是需要做的任务的方法所在。

  在使用方法中我们需要将Callable传给FutureTask的构造方法,所以我们先看FutureTask的构造方法:

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

  如果callable为空,则抛出异常,否则执行赋值操作,并将state状态改成NEW,即是初始化状态,这里说一下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;

  所以初始化时state的值为0,表示当前为初始化状态。

  FutureTask实现了Runnable,所以必然又run方法去供线程使用,接下来就看FutureTask重写的run()方法:

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 must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}

  第一步判断state是否为初始化状态,不为初始化状态将将当前线程设置为FutureTask的执行线程,设置失败停止方法,经过第一步还能往下执行,则当前的state必然是初始化状态,得到Callable实例,及真正需要执行的任务代码,判断是否为空,且状态是否为初始化状态,判断成功,则执行callable的call()方法,并将执行结果赋值给result,将执行标记ran赋值为ture,执行成功时,ran为true时调用set()方法保存结果,

  set()方法:

  protected void set(V v) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();
}
}

  将状态从NEW偏移到COMPLETING(正在执行中),将结果保存到outcome中,(outcome是一个Object类型,不止可以保存结果,还可以保存异常信息),保存完成后将偏移量改为NORMAL(正常执行完毕的状态),调用finishCompletion()方法。

  finishCompletion()方法:

 private void finishCompletion() {
// assert state > COMPLETING;
for (WaitNode q; (q = waiters) != null;) {
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
for (;;) {
Thread t = q.thread;
if (t != null) {
q.thread = null;
LockSupport.unpark(t);
}
WaitNode next = q.next;
if (next == null)
break;
q.next = null; // unlink to help gc
q = next;
}
break;
}
} done(); callable = null; // to reduce footprint
}

  因为在执行过程中可能会未执行完成就调用了get方法,此时get方法会将想要获取结果的线程都等待在一个等待队列中,所以finishCompletion()的功能就是遍历等待队列,并将等带队列中所有的有效线程唤醒(unpark)。此时等待get()的线程将会继续执行,

  当调用call方法出现异常时,result未空,ran赋值未false,调用setException()方法;

  setException(Throwable t):

 protected void setException(Throwable t) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = t;
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
finishCompletion();
}
}

  首先更改状态为COMPLETING,将异常信息保存到outcome中,更改状态为EXCEPTIONAL(表示异常执行结束),调用finishCompletion()唤醒等待线程。run执行完成;

  FutureTask还有一个重要的方法就是get()方法,用于获取Callable的call方法返回的结果或执行过程中出现的异常信息。

  get():

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

  当状态小于等于COMPLETING时,表示当前任务还没有处于终止状态,即可能正在初始化或者是正在执行中,调用awaitDone()方法将线程放入等待队列,并等待起来,直到被唤醒,最后返回report(s)执行结果,

report(s:

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

  如果正常执行结束,返回执行结果,s >= CANCELLED表示线程不可用状态,抛出异常CancellationException,否则就是异常执行结束,抛出ExecutionException(),这样就可以拿到执行结果。

  FutureTask其核心的原理也是等待/唤醒,当调用get方法没有结果时,线程等待,当set()方法赋值成功,表示任务执行完成,有值可以返回时,唤醒等待的线程,get()方法上等待的线程被唤醒,继续执行,最后返回结果。

原文 并发编程学习笔记(11)----FutureTask的使用及实现

并发编程学习笔记(11)----FutureTask的使用及实现的更多相关文章

  1. JUC并发编程学习笔记

    JUC并发编程学习笔记 狂神JUC并发编程 总的来说还可以,学到一些新知识,但很多是学过的了,深入的部分不多. 线程与进程 进程:一个程序,程序的集合,比如一个音乐播发器,QQ程序等.一个进程往往包含 ...

  2. Java并发编程学习笔记

    Java编程思想,并发编程学习笔记. 一.基本的线程机制 1.定义任务:Runnable接口 线程可以驱动任务,因此需要一种描述任务的方式,这可以由Runnable接口来提供.要想定义任务,只需实现R ...

  3. 并发编程学习笔记(15)----Executor框架的使用

    Executor执行已提交的 Runnable 任务的对象.此接口提供一种将任务提交与每个任务将如何运行的机制(包括线程使用的细节.调度等)分离开来的方法.通常使用 Executor 而不是显式地创建 ...

  4. 并发编程学习笔记(14)----ThreadPoolExecutor(线程池)的使用及原理

    1. 概述 1.1 什么是线程池 与jdbc连接池类似,在创建线程池或销毁线程时,会消耗大量的系统资源,因此在java中提出了线程池的概念,预先创建好固定数量的线程,当有任务需要线程去执行时,不用再去 ...

  5. 并发编程学习笔记(13)----ConcurrentLinkedQueue(非阻塞队列)和BlockingQueue(阻塞队列)原理

    · 在并发编程中,我们有时候会需要使用到线程安全的队列,而在Java中如果我们需要实现队列可以有两种方式,一种是阻塞式队列.另一种是非阻塞式的队列,阻塞式队列采用锁来实现,而非阻塞式队列则是采用cas ...

  6. 并发编程学习笔记(12)----Fork/Join框架

    1. Fork/Join 的概念 Fork指的是将系统进程分成多个执行分支(线程),Join即是等待,当fork()方法创建了多个线程之后,需要等待这些分支执行完毕之后,才能得到最终的结果,因此joi ...

  7. 并发编程学习笔记(10)----并发工具类CyclicBarrier、Semaphore和Exchanger类的使用和原理

    在jdk中,为并发编程提供了CyclicBarrier(栅栏),CountDownLatch(闭锁),Semaphore(信号量),Exchanger(数据交换)等工具类,我们在前面的学习中已经学习并 ...

  8. 并发编程学习笔记(9)----AQS的共享模式源码分析及CountDownLatch使用及原理

    1. AQS共享模式 前面已经说过了AQS的原理及独享模式的源码分析,今天就来学习共享模式下的AQS的几个接口的源码. 首先还是从顶级接口acquireShared()方法入手: public fin ...

  9. 并发编程学习笔记(8)----ThreadLocal的使用及源码分析

    1. ThreadLocal的理解 ThreadLocal,顾名思义,就是线程的本地变量,ThreadLocal会为每个线程创建一个本地变量副本,使得使用ThreadLocal管理的变量在多线程的环境 ...

随机推荐

  1. Android Java包各种功能简述

    开发Android应用程序基本上使用的都是Java语言. 那么要想灵活的应用这一系统,就应当熟悉当中的Android Java包的各种功能. 一般的JAVA应用中.假设需用引用基础类库,通常须要使用例 ...

  2. 【Android】使用 SwipeRefreshLayout 实现下拉刷新

    今天在codepath 上看到一个开源项目 [点击查看]使用到了 SwipeRefreshLayout 实现了下拉刷新,但演示样例并不完整,于是自己就动手写了下.之前看到郭霖的博客上也有介绍下拉刷新, ...

  3. 【codevs2183】匹配字符串

    KMP裸题 #include<algorithm> #include<iostream> #include<cstdlib> #include<cstring ...

  4. [RK3288][Android6.0] 系统按键驱动流程分析【转】

    本文转载自:http://blog.csdn.net/kris_fei/article/details/77894406 Rockchip的按键驱动位于 kernel/drivers/input/ke ...

  5. Tarjan求桥

    传送门(poj3177) 这道题是Tarjan求桥的模板题.大意是要求在原图上加上数量最少的边,使得整张图成为一个边双联通分量. 具体的做法是,先在图中求出所有的桥,之后把边双联通分量缩成点,这样的话 ...

  6. [luogu2620]虫洞

    https://www.zybuluo.com/ysner/note/1284536 题面 给一个一维坐标系,出发点为\(0\),目标点为\(w\). 每\(1\)秒可以往后移不超过\(s\)个单位距 ...

  7. 杂项-Java:MyBatis

    ylbtech-杂项-Java:MyBatis 1.返回顶部 1. MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundatio ...

  8. ubuntu 16.04 Python Anaconda 安装

    Python Anaconda 不同版本在官网上的位置:https://www.anaconda.com/download/#linux 进入官网=>Changelog=>Product ...

  9. javascript BOM基本知识

    1.BOM(Bowser Object Model浏览器对象模型) 浏览器创建的对象通常称作文档(Document)对象,它是浏览器使用的众多对象的一部分,浏览器操作的对象结合起来称作浏览器对象模型( ...

  10. 栗染-Error parsing D:\sdkforas\android-sdk-windows\system-images\android-24\android-wear\x86\devices.xml

    每次打开android virtual device manager 下面都会出现这样的问题 解决办法: 打开自己安装的sdk目录,找到/tools/lib/devices.xml去替换图中路径里面的 ...