提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  其他

当前栏目

AQS同步组件-FutureTask、ForkJoin解析和用例

同步组件 解析 用例 AQS FutureTask ForkJoin
2023-06-13 09:13:24 时间

FutureTask原理

FutureTask间接实现了runnable接口和future接口，说明了futureTask是runnable与callnable的集合体，即是有返回值的runnable方法。因此，FutureTask可以交给Executor执行，也可以由调用线程直接执行（FutureTask.run()）。

源码分析

构造函数

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

    public FutureTask(Runnable runnable, V result) {
        //当构造方法传入参数为Runnable，会通过Executors.callable方法将其转换成Callable
        this.callable = Executors.callable(runnable, result);
        this.state = NEW;       // ensure visibility of callable
    }
FutureTask新建提供两个构造方法来封装Callable和Runnable，当构造方法传入参数为Runnable，会通过Executors.callable方法将其转换成Callable。

常用方法

/**
* 可能的状态转换::
* 新建 -> 已完成 -> 正常
* 新建 -> 已完成 -> 异常
* 新建 -> 已取消
* 新建 -> 中断ing -> 已中断
 */
private volatile int 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;

boolean cancel(boolean mayInterruptIfRunning);//取消任务
boolean isCancelled();//是否被取消
boolean isDone();//计算是否完成
//get方法，获取执行结果，如果当前线程还没有执行完成, get方法会被阻塞。
public V get()
//可以设置超时时间并获取执行结果，如果当前线程还没有执行完成, get方法会被阻塞。
public V get(long timeout, TimeUnit unit)
    
/**
  * awaitDone方法其实是个死循环，直到task状态变为已完成状态或者等待时间超过
  *超时时间或者线程中断才会跳出循环，程序结束；
  *为了节省开销，线程不会一直自旋等待，而是会阻塞，使用LockSupport的park系列方法实现线程阻塞
 */
private int awaitDone(boolean timed, long nanos)
    throws InterruptedException {
    final long deadline = timed ? System.nanoTime() + nanos : 0L;
    WaitNode q = null;
    boolean queued = false;
    for (;;) {
        //如果线程中断，将当前线程从等待队列waiters中移除，抛出中断异常
        if (Thread.interrupted()) {
            removeWaiter(q);
            throw new InterruptedException();
        }

        int s = state;
        //如果线程已完成，设为null
        if (s > COMPLETING) {
            if (q != null)
                q.thread = null;
            return s;
        }
        //如果正在执行，让出cpu
        else if (s == COMPLETING) // cannot time out yet
            Thread.yield();
       	//如果节点为空，则初始化节点
        else if (q == null)
            q = new WaitNode();
        else if (!queued)
            //CAS
            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);
    }
}

根据FutureTask的run方法执行的时机，FutureTask可以处于以下三种执行状态：

  1. 未启动：在FutureTask.run()还没执行之前，FutureTask处于未启动状态。当创建一个FutureTask对象，并且run()方法未执行之前，FutureTask处于未启动状态。
  2. 已启动：FutureTask对象的run方法启动并执行的过程中，FutureTask处于已启动状态。
  3. 已完成：FutureTask正常执行结束，或者FutureTask执行被取消(FutureTask对象cancel方法)，或者FutureTask对象run方法执行抛出异常而导致中断而结束，FutureTask都处于已完成状态。
  • 当FutureTask处于未启动或已启动状态时，执行FutureTask.get()方法将导致调用线程阻塞
  • 当FutureTask处于已完成状态时，执行FutureTask.get()方法将导致调用线程立即返回结果或抛出异常
  • 当FutureTask处于未启动状态时，执行FutureTask.cancel()方法将导致此任务永远不会被执行
  • 当FutureTask处于已启动状态时，执行FutureTask.cancel（true）方法将以中断执行此任务线程的方式来试图停止任务
  • 当FutureTask处于已启动状态时，执行FutureTask.cancel（false）方法将不会对正在执行此任务的线程产生影响（让正在执行的任务运行完成）
  • 当FutureTask处于已完成状态时，执行FutureTask.cancel（…）方法将返回false。

使用案例

FutureTask、Runnable、Callable

public static void main(String[] args) throws Exception {
        FutureTask<String> futureTask = new FutureTask<String>(new Callable<String>() {
            @Override
            public String call() throws Exception {
                log.info("callable耗时任务开始");
                //耗时任务
                Thread.sleep(5000);
                log.info("callable耗时任务完成");
                return "耗时任务：报告！我已完成";
            }
        });

        ExecutorService executor = Executors.newSingleThreadExecutor();
        executor.submit(futureTask);
   		//executor.execute(futureTask);
        log.info("主线程任务开始");
        Thread.sleep(1000);
        log.info("主线程任务完成");
        log.info("等待耗时任务完成。。。");
        //获取耗时任务的返回结果，如果未返回，主线程将阻塞，处于等待状态
        String result = futureTask.get();
        log.info("result：{}", result);
    }

输出结果如下：

12:22:06.250 [main] INFO com.zjq.aqs.FutureTaskExample - 主线程任务开始
12:22:06.250 [Thread-0] INFO com.zjq.aqs.FutureTaskExample - callable耗时任务开始
12:22:07.254 [main] INFO com.zjq.aqs.FutureTaskExample - 主线程任务完成
12:22:07.254 [main] INFO com.zjq.aqs.FutureTaskExample - 等待耗时任务完成。。。
12:22:11.254 [Thread-0] INFO com.zjq.aqs.FutureTaskExample - callable耗时任务完成
12:22:11.254 [main] INFO com.zjq.aqs.FutureTaskExample - result：耗时任务：报告！我已完成
  • 可以把FutureTask交给Executor执行
  • 也可以通过ExecutorService.submit（…）方法返回一个FutureTask，然后执行FutureTask.get()方法或FutureTask.cancel（…）方法
  • 除此以外，还可以单独使用FutureTask

Future、Callable

public static void main(String[] args) throws Exception {

        ExecutorService executor = Executors.newCachedThreadPool();
        Future<String> future = executor.submit(new MyCallable());
        log.info("主线程任务开始");
        Thread.sleep(1000);
        log.info("主线程任务完成");
        log.info("等待耗时任务完成。。。");
        //获取耗时任务的返回结果，如果未返回，主线程将阻塞，处于等待状态
        String result = future.get();
        log.info("result：{}", result);
    }

    static class MyCallable implements Callable<String> {

        @Override
        public String call() throws Exception {
            log.info("callable耗时任务开始");
            //耗时任务
            Thread.sleep(5000);
            log.info("callable耗时任务完成");
            return "耗时任务：报告！我已完成";
        }
    }

当一个线程需要等待另一个线程把某个任务执行完后它才能继续执行，此时可以使用FutureTask.

ForkJoin

ForkJoin是Java7提供的一个并行执行任务的框架，是把大任务分割成若干个小任务，待小任务完成后将结果汇总成大任务结果的框架。主要采用的是工作窃取算法，工作窃取算法是指某个线程从其他队列里窃取任务来执行。Fork就是把一个大任务切分为若干子任务并行的执行，Join就是合并这些子任务的执行结果，最后得到这个大任务的结果。 工作窃取（work-stealing）算法是指某个线程从其他队列里窃取任务来执行. 假如我们需要做一个比较大的任务，可以把这个任务分割为若干互不依赖的子任务，为了减少线程间的竞争，把这些子任务分别放到不同的队列里，并为每个 队列创建一个单独的线程来执行队列里的任务，线程和队列一一对应. 比如A线程负责处理A列里的任务。但是，有的线程会先把自己队列里的任务干完，而其他线程对应的队列里还有任务等待处理。 干完活的线程与其等着，不如去帮其他线程干活，于是它就去其他线程的队列里窃取一个任务来执行。而在这时它们会访问同一个队列，所以为了减少窃取任务线程和被窃取任务线程之间的竞争，通常会使用双端队列，被窃取任务线程永远从双端队列的头部拿任务执行，而窃取任务的线程永远从双端队列的尾部拿任务执行。

优点

  • 充分利用线程进行并行计算，减少了线程间的竞争。

缺点

  • 在某些情况下还是存在竞争，比如双端队列里只有一个任务时。
  • 该算法会消耗了更多的系统资源，比如创建多个线程和多个双端队列

参考案例：

/**
 * ForkJoinTask
 * 通常情况下，我们不需要直接继承ForkJoinTask类，只需要继承它的子类。
 * Fork/Join框架提供了以下两个子类：
 * RecursiveAction：用于没有返回结果的任务
 * RecursiveTask：用于有返回结果的任务
 * @author zjq
 */
@Slf4j
public class ForkJoinTaskExample extends RecursiveTask<Integer> {

    public static final int threshold = 2;
    private int start;
    private int end;

    public ForkJoinTaskExample(int start, int end) {
        this.start = start;
        this.end = end;
    }

    /**
     * 执行fork()和join()操作
     * @return
     */
    @Override
    protected Integer compute() {
        int sum = 0;

        //如果任务足够小就计算任务
        boolean canCompute = (end - start) <= threshold;
        if (canCompute) {
            for (int i = start; i <= end; i++) {
                sum += i;
            }
        } else {
            // 如果任务大于阈值，就分裂成两个子任务计算
            int middle = (start + end) / 2;
            ForkJoinTaskExample leftTask = new ForkJoinTaskExample(start, middle);
            ForkJoinTaskExample rightTask = new ForkJoinTaskExample(middle + 1, end);

            // 执行子任务
            leftTask.fork();
            rightTask.fork();

            // 等待任务执行结束合并其结果
            int leftResult = leftTask.join();
            int rightResult = rightTask.join();

            // 合并子任务
            sum = leftResult + rightResult;
        }
        return sum;
    }

    public static void main(String[] args) {
        //ForkJoinTask需要通过ForkJoinPool来执行
        ForkJoinPool forkjoinPool = new ForkJoinPool();

        //生成一个计算任务，计算1+2+3+4
        ForkJoinTaskExample task = new ForkJoinTaskExample(1, 100);

        //执行一个任务
        Future<Integer> result = forkjoinPool.submit(task);

        try {
            log.info("result:{}", result.get());
        } catch (Exception e) {
            log.error("exception", e);
        }
    }
}

BlockingQueue阻塞队列

主要应用场景：生产者消费者模型，是线程安全的

阻塞情况

1、当队列满了进行入队操作 2、当队列空了的时候进行出队列操作

四套方法

BlockingQueue提供了四套方法，分别来进行插入、移除、检查。每套方法在不能立刻执行时都有不同的反应。

  • Throws Exceptions ：如果不能立即执行就抛出异常。
  • Special Value：如果不能立即执行就返回一个特殊的值。
  • Blocks：如果不能立即执行就阻塞
  • Times Out：如果不能立即执行就阻塞一段时间，如果过了设定时间还没有被执行，则返回一个值

实现类

  • ArrayBlockingQueue：它是一个有界的阻塞队列，内部实现是数组，初始化时指定容量大小，一旦指定大小就不能再变。采用FIFO方式存储元素。
  • DelayQueue：阻塞内部元素，内部元素必须实现Delayed接口，Delayed接口又继承了Comparable接口，原因在于DelayQueue内部元素需要排序，一般情况按过期时间优先级排序。

DalayQueue内部采用PriorityQueue与ReentrantLock实现。

public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
    implements BlockingQueue<E> {

    private final transient ReentrantLock lock = new ReentrantLock();
    private final PriorityQueue<E> q = new PriorityQueue<E>();
    ...
}
  • LinkedBlockingQueue：大小配置可选，如果初始化时指定了大小，那么它就是有边界的。不指定就无边界（最大整型值）。内部实现是链表，采用FIFO形式保存数据。
public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);//不指定大小，无边界采用默认值，最大整型值
}
  • PriorityBlockingQueue:带优先级的阻塞队列。无边界队列，允许插入null。插入的对象必须实现Comparator接口，队列优先级的排序规则就是按照我们对Comparable接口的实现来指定的。我们可以从PriorityBlockingQueue中获取一个迭代器，但这个迭代器并不保证能按照优先级的顺序进行迭代。
  • SynchronusQueue：只能插入一个元素，同步队列，无界非缓存队列，不存储元素。

相关文章