java并发(十七)——FutureTask

Runnable

Runnable接口是我们最熟悉的，它只有一个run函数。然后使用某个线程去执行该runnable即可实现多线程，Thread类在调用start()函数后就是执行的是Runnable的run()函数。Runnable最大的缺点在于run函数没有返回值。

public interface Runnable {
    public abstract void run();
}

Callable

Callable接口和Runnable接口类似，它有一个call函数。使用某个线程执行Callable接口实质就是执行其call函数。call方法和run方法最大的区别就是call方法有返回值：

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

可以看到，这是一个泛型接口，call()函数返回的类型就是传递进来的V类型。

那么怎么使用Callable呢？一般情况下是配合ExecutorService来使用的，在ExecutorService接口中声明了若干个submit方法的重载版本：

<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);

第一个submit方法里面的参数类型就是Callable。暂时只需要知道Callable一般是和ExecutorService配合来使用的，具体的使用方法讲在后面讲述。一般情况下我们使用第一个submit方法和第三个submit方法，第二个submit方法很少使用。

Future

Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。

Future类位于java.util.concurrent包下，它是一个接口：

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

在Future接口中声明了5个方法，下面依次解释每个方法的作用：

cancel()： 用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
isCancelled()： 表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
isDone(): 表示任务是否已经完成，若任务完成，则返回true；
get(): 用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
get(long timeout, TimeUnit unit)： 用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。

也就是说Future提供了三种功能：

判断任务是否完成；
能够中断任务；
能够获取任务执行结果。

因为Future只是一个接口，所以是无法直接用来创建对象使用的，因此就有了下面的FutureTask。

FutureTask

Future只是一个接口，在实际使用过程中，诸如ThreadPoolExecutor返回的都是一个FutureTask实例。我们先来看一下FutureTask的实现：

public class FutureTask<V> implements RunnableFuture<V>

FutureTask类实现了RunnableFuture接口，我们看一下RunnableFuture接口的实现：

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

可以看到，FutureTask是一个RunnableFuture，而RunnableFuture实现了Runnbale又实现了Futrue这两个接口。

FutureTask的构造方法

接下来看下FutureTask的构造方法：

	//接受Callable对象作为参数
	public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;      
    }
    
	//接受Runnable对象作为参数
	public FutureTask(Runnable runnable, V result) {
		//将Runnable转为Callable对象
	    this.callable = Executors.callable(runnable, result);//将Runnable转为Callable对象
	    this.state = NEW;     
	}

当参数是runnable时，会调用Executors方法进行转换。

	//callable方法，将Runnable转为一个Callable对象，包装设计模式
    public static <T> Callable<T> callable(Runnable task, T result) {
        if (task == null)
            throw new NullPointerException();
        return new RunnableAdapter<T>(task, result);
    }
    
	//RunnableAdapter是Executors的一个内部类，实现了Callable接口
    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;
        }
    }

可以看到，构造FutureTask时，无论传入的是Runnable还是Callable，最终都实现了Callable接口。

FutureTask主要成员

接下来看下FutureTask类的主要成员变量：

public class FutureTask<V> implements RunnableFuture<V> {
	/*
	* FutureTask中定义了一个state变量，用于记录任务执行的相关状态 ，状态的变化过程如下
	* NEW -> COMPLETING -> NORMAL
    * NEW -> COMPLETING -> EXCEPTIONAL
    * NEW -> CANCELLED
    * NEW -> INTERRUPTING -> INTERRUPTED
	*/
	private volatile int state;
	//主流程状态
	//当FutureTask实例刚刚创建到callbale的call方法执行完成前，处于此状态
    private static final int NEW          = 0;
    //callable的call方法执行完成或出现异常时，首先进行此状态
    private static final int COMPLETING   = 1;
    //callable的call方法正常结束时，进入此状态，将outcom设置为正常结果
    private static final int NORMAL       = 2;
    //callable的call方法异常结束时，进入此状态，将outcome设置为抛出的异常
    private static final int EXCEPTIONAL  = 3;
    // FutureTask任务尚未执行，即还在任务队列的时候，调用了cancel方法，进入此状态
    private static final int CANCELLED    = 4;
    // FutureTask的run方法已经在执行，收到中断信号，进入此状态
    private static final int INTERRUPTING = 5;
    // 任务成功中断后，进入此状态
    private static final int INTERRUPTED  = 6;

    //需要执行的任务，提示：如果提交的是Runnable对象，会先转换为Callable对象，这是构造方法参数
    private Callable<V> callable;
    //任务运行的结果
    private Object outcome; // non-volatile, protected by state reads/writes
    //执行此任务的线程
    private volatile Thread runner;
    //等待该FutureTask的线程链表，对于同一个FutureTask，如果多个线程调用了get方法，对应的线程都会加入到waiters链表中，同时当FutureTask执行完成后，也会告知所有waiters中的线程
    private volatile WaitNode waiters;
}

FutureTask的成员变量并不复杂，主要记录以下几部分信息：

状态
任务（callable）
结果（outcome）
等待线程（waiters）

FutureTask的执行过程

run方法

接下来开始看一个FutureTask的执行过程，FutureTask执行任务的方法当然还是run方法：

public void run() {
    //保证callable任务只被运行一次
    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 = null;
        int s = state;
        //判断该任务是否正在响应中断，如果中断没有完成，则等待中断操作完成
        if (s >= INTERRUPTING)
            handlePossibleCancellationInterrupt(s);
    }
}

如果状态不为new或者运行线程runner失败，说明当前任务已经被其他线程启动或者已经被执行过，直接返回false。
调用call方法执行核心任务逻辑。如果调用成功则执行set(result)方法，将state状态设置成NORMAL。如果调用失败抛出异常则执行setException(ex)方法，将state状态设置成EXCEPTIONAL，唤醒所有在get()方法上等待的线程。
如果当前状态为INTERRUPTING(步骤2已CAS失败)，则一直调用Thread.yield()直至状态不为INTERRUPTING。

set、setException方法

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

两个方法的逻辑基本一致，先通过CAS操作将状态从NEW置为COMPLETING，然后再将最终状态分别置为NORMAL或者EXCEPTIONAL，最后再调用finishCompletion方法。

finishCompletion方法

private void finishCompletion() {
    for (WaitNode q; (q = waiters) != null;) {
        //通过CAS把栈顶的元素置为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
}

finishCompletion的逻辑也比较简单：

遍历waiters链表，取出每一个节点：每个节点都代表一个正在等待该FutureTask结果（即调用过get方法）的线程。
通过 LockSupport.unpark(t)唤醒每一个节点，通知每个线程，该任务执行完成。

get方法

在finishCompletion方法中，FutureTask会通知waiters链表中的每一个等待线程，那么这些线程是怎么被加入到waiters链表中的呢？上文已经讲过，当在一个线程中调用了get方法，该线程就会被加入到waiters链表中。所以接下来看下get方法：

public V get(long timeout, TimeUnit unit)
    throws InterruptedException, ExecutionException, TimeoutException {
    if (unit == null)
        throw new NullPointerException();
    int s = state;
    if (s <= COMPLETING &&
        (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
        throw new TimeoutException();
    return report(s);
}

get方法很简答，主要就是调用awaitDone方法：

private int awaitDone(boolean timed, long nanos)
    throws InterruptedException {
    //截止时间
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    WaitNode q = null;
    boolean queued = false;
    for (;;) {
        //如果该线程执行interrupt()方法，则从队列中移除该节点，并抛出异常
        if (Thread.interrupted()) {
            removeWaiter(q);
            throw new InterruptedException();
        }
        int s = state;
        //如果state状态大于COMPLETING 则说明任务执行完成，或取消
        if (s > COMPLETING) {
            if (q != null)
                q.thread = null;
            return s;
        }
        //如果state=COMPLETING，则使用yield，因为此状态的时间特别短，通过yield比挂起响应更快。
        else if (s == COMPLETING) // cannot time out yet
            Thread.yield(); //挂起本线程。
        //构建节点
        else if (q == null)
            q = new WaitNode();
        //把当前节点入栈
        else if (!queued)
            queued = UNSAFE.compareAndSwapObject(this, waitersOffset, q.next = waiters, q);
        //如果需要阻塞指定时间，则使用LockSupport.parkNanos阻塞指定时间
        //如果到指定时间还没执行完，则从队列中移除该节点，并返回当前状态
        else if (timed) {
            nanos = deadline - System.nanoTime();
            if (nanos <= 0L) {
                removeWaiter(q);
                return state;
            }
            LockSupport.parkNanos(this, nanos);//阻塞当前线程nanos秒
         }
            //阻塞当前线程
        else
                LockSupport.park(this);//阻塞当前线程
        }
}

整个方法的大致逻辑主要分为以下几步：

如果当前状态值大于COMPLETING，说明已经执行完成或者取消，直接返回
如果state=COMPLETING，则使用yield，因为此状态的时间特别短，通过yield比挂起响应更快
如果当前线程是首次进入循环，为当前线程创建wait节点加入到waiters链表中
根据是否定时将当前线程挂起（LockSupport.parkNanos LockSupport.park）来阻塞当前线程，直到超时或者线程被finishCompletion方法唤醒
当线程挂起超时或者被唤醒后，重新循环执行上述逻辑

get方法是FutureTask中的关键方法，了解了get方法逻辑也就了解为什么当调用get方法时线程会被阻塞直到任务运行完成。

cancel方法
cancel方法用于结束当前任务：

public boolean cancel(boolean mayInterruptIfRunning) {
    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;
}

根据mayInterruptIfRunning是否为true，CAS设置状态为INTERRUPTING或CANCELLED，设置成功，继续第二步，否则返回false
如果mayInterruptIfRunning为true，调用runner.interupt()，设置状态为INTERRUPTED
唤醒所有在get()方法等待的线程

java并发(十七)——FutureTask

Runnable

Callable

Future

FutureTask

FutureTask的构造方法

FutureTask主要成员

FutureTask的执行过程

CORS error 但是 status code 是200 OK

压缩上传的GPU数据的方案

使用skopeo同步镜像

Sentinel學習(八) —— 規則持久化

Nacos學習(一) —— Nacos配置管理實戰

Sentinel學習(五) —— 控制檯使用和源碼

Kafka學習(二)——生產者

Kafka學習(一)——初識與入門

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結