线程池执行特殊任务

如何批量执行任务

invokeAll

List<future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
tasks:任务集合
执行批量任务，当所有任务完成时，返回Future集合
invokeAll按照顺序执行任务，并且按照顺序返回执行结果
该方法能批量执行的任务只能是Callable任务

具体代码

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        //创建任务列表
        List<Task> tasks = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            tasks.add(new Task(i));
        }
        //创建线程池
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        try {
            //提交任务列表
            List<Future<Integer>> futures = threadPool.invokeAll(tasks);
            //获取任务执行结果
            for (Future<Integer> future : futures) {
                System.out.println(future.get());
            }
            //输出任务执行结果
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        } finally {
            //关闭线程池
            threadPool.shutdown();
        }
    }
}

class Task implements Callable<Integer> {
    public Task(int index) {
        this.index = index;
    }

    private final int index;

    @Override
    public Integer call() throws InterruptedException {
        //线程休眠1秒
        Thread.sleep(1000);
        return index;
    }
}

超时的invokeAll和invokeAny

List<future<T>> invokeAll(Collection<? extends Callable<T>> tasks,long timeout,TimeUnit unit)
T invokeAny(Collection<? extends Callable<T>> tasks,long timeout,TimeUnit unit)
指定时间内完成任务，完成不了的全部取消
timeout:超时时间
unit:时间单位
List<Future<Integer>> futures = threadPool.invokeAll(tasks,3,TimeUnit.SECONDS);

invokeAny

执行批量任务，返回最先完成的任务的执行结果，取消未完成的任务
Integer futures = threadPool.invokeAny(tasks);

执行定时或延时的任务

schedule

ScheduledExecutorService接口中的schedule方法
调度线程池:具备执行定时、延时、周期性任务的线程池
构造方法：可以通过自身的构造方法创建，也可以听过工具类Executors来创建

      方法                                                描述
newSingleThreadExecutor()                 创建池中只有一个线程的调度线程池
newSingleThreadExecutor(ThreadFactory)    创建池中只有一个线程的调度线程池，并指定线程工厂
newScheduledThreadPool(int)               创建指定核心线程数的调度线程池
newScheduledThreadPool(int, ThreadFactory)  创建指定核心线程数的调度线程池，并指定线程工厂

ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit)
延时执行一次Runnable任务的schedule方法

具体代码

package org.example;

import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        //创建任务
        Task task = new Task();
        //创建调度线程池
        ScheduledExecutorService scheduledThreadPool =Executors.newScheduledThreadPool(5);
//输出当前时间
        System.out.println(LocalTime.now());
            //提交任务列表
            scheduledThreadPool.schedule(task,3,TimeUnit.SECONDS);
            //关闭线程池
            scheduledThreadPool.shutdown();
    }
}

class Task implements Runnable {

    @Override
    public void run() {
//输出运行时间
        System.out.println(LocalTime.now());
    }
}

输出结果

16:53:42.704770400
16:53:45.716761600
可以看出是延迟了3s运行

ScheduledFuture<?> schedule(Callable<V> callable, long delay, TimeUnit unit)
延时执行一次Runnable任务的schedule方法

执行周期、重复性任务

scheduleAtFixedRate

ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)
command:任务
initialDelay:延时时间
period:固定时间
scheduleAtFixedRate周期为固定时间，每过一个固定时间，不管上一个任务是否完成
scheduleAtFixedRate

具体代码

package org.example;

import java.time.LocalTime;
import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        //创建任务
        Task task = new Task();
        //创建调度线程池
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
        System.out.println(LocalTime.now());
        //提交任务列表
        scheduledThreadPool.scheduleAtFixedRate(task, 1, 1, TimeUnit.SECONDS);
        Thread.sleep(1000 * 5);
        //关闭线程池
        scheduledThreadPool.shutdown();
    }
}

class Task implements Runnable {

    @Override
    public void run() {
        System.out.println(LocalTime.now());
    }
}

scheduleWithFixedDelay

ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long period, TimeUnit unit)
scheduleWithFixedDelay，是以上一个任务结束时开始计时，固定时间过去后，立即执行。