这篇文章主要介绍了Java 使用线程池执行多个任务的示例，帮助大家更好的理解和学习使用Java，感兴趣的朋友可以了解下

在执行一系列带有IO操作（例如下载文件），且互不相关的异步任务时，采用多线程可以很极大的提高运行效率。线程池包含了一系列的线程，并且可以管理这些线程。例如：创建线程，销毁线程等。本文将介绍如何使用Java中的线程池执行任务。

1 任务类型

在使用线程池执行任务之前，我们弄清楚什么任务可以被线程池调用。按照任务是否有返回值可以将任务分为两种，分别是实现Runnable的任务类（无参数无返回值）和实现Callable接口的任务类（无参数有返回值）。在打代码时根据需求选择对应的任务类型。

1.1 实现Runnable接口的类

多线程任务类型，首先自然想到的就是实现 Runnable 接口的类，Runnable接口提供了一个抽象方法run，这个方法无参数，无返回值。例如：

Runnable task = new Runnable() {
  @Override
  public void run() {
    System.out.println("Execute task.");
  }
};

或者Java 8 及以上版本更简单的写法

Runnable task = ()->{
  System.out.println("Execute task.");
};

1.2 实现Callable接口的类
于Runnable一样Callable也只有一个抽象方法，不过该抽象方法有返回值。在实现该接口的时候需要制定返回值的类型。例如：

Callable<String> callableTask = ()-> "finished";

于Runnable一样Callable也只有一个抽象方法，不过该抽象方法有返回值。在实现该接口的时候需要制定返回值的类型。例如：

Callable<String> callableTask = ()-> "finished";

2 线程池类型

java.util.concurrent.Executors 提供了一系列静态方法来创建各种线程池。下面例举出了主要的一些线程池及特性，其它未例举线程池的特性可由下面这些推导出来。

2.1 线程数固定的线程池 Fixed Thread Pool

顾名思义，这种类型线程池线程数量是固定的。如果线程数量设置为n，则任何时刻该线程池最多只有n个线程处于运行状态。当线程池中处于饱和运行状态时，再往线程池中提交的任务会被放到执行队列中。如果线程池处于不饱和状态，线程池也会一直存在，直到ExecuteService 的shutdown方法被调用，线程池才会被清除。

// 创建线程数量为5的线程池。
ExecutorService executorService = Executors.newFixedThreadPool(5);

2.2 可缓存的线程池 Cached Thread Pool
这种类型的线程池初始大小为0个线程，随着往池里不断提交任务，如果线程池里面没有闲置线程（0个线程也表示没有闲置线程），则会创建新的线程，保证没有任务在等待；如果有闲置线程，则复用闲置状态线程执行任务。处于闲置状态的线程只会在线程池中缓存60秒，闲置时间达到60s的线程会被关闭并移出线程池。在处理大量短暂的（官方说法：short-lived）异步任务时可以显著得提供程序性能。

//创建一个可缓存的线程池 
ExecutorService executorService = Executors.newCachedThreadPool();

2.3 单线程池
这或许不能叫线程池了，由于它里面的线程永远只有1个，而且自始至终都只有1个（为什么说这句话，因为要和 Executors.newFixedThreadPool(1) 区别开来），所以还是叫它“单线程池把”。你尽可以往单线程池中添加任务，但是每次只执行1个，且任务是按顺序执行的。如果前面的任务出现了异常，当前线程会被销毁，但1个新的线程会被创建用来执行后面的任务。以上这些和线程数只有1个的线程Fixed Thread Pool一样。两者唯一不同的是， Executors.newFixedThreadPool(1) 可以在运行时修改它里面的线程数，而 Executors.newSingleThreadExecutor() 永远只能有1个线程。

//创建一个单线程池
ExecutorService executorService = Executors.newSingleThreadExecutor();

2.4 工作窃取线程池
扒开源码，会发现工作窃取线程池本质是 ForkJoinPool ，这类线程池充分利用CPU多核处理任务，适合处理消耗CPU资源多的任务。它的线程数不固定，维护的任务队列有多个，当一个任务队列完成时，相应的线程会从其它的任务队列中窃取任务执行，这也意味着任务的开始执行顺序并和提交顺序相同。如果有更高的需求，可以直接通过ForkJoinPool获取线程池。

//创建一个工作窃取线程池，使用CPU核数等于机器的CPU核数
ExecutorService executorService = Executors.newWorkStealingPool();

//创建一个工作窃取线程池，使用CPU 3 个核进行计算，工作窃取线程池不能设置线程数
ExecutorService executorService2 = Executors.newWorkStealingPool(3);

2.5 计划任务线程池
计划任务线程池可以按计划执行某些任务，例如：周期性的执行某项任务。

// 获取一个大小为2的计划任务线程池
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(2);
// 添加一个打印当前线程信息计划任务，该任务在3秒后执行
scheduledExecutorService.schedule(() -> { System.out.println(Thread.currentThread()); }, 3, TimeUnit.SECONDS);
// 添加一个打印当前线程信息计划任务，该任务在2秒后首次执行，之后每5秒执行一次。如果任务执行时间超过了5秒，则下一次将会在前一次执行完成之后立即执行
scheduledExecutorService.scheduleAtFixedRate(() -> { System.out.println(Thread.currentThread()); }, 2, 5, TimeUnit.SECONDS);
// 添加一个打印当前线程信息计划任务，该任务在2秒后首次执行，之后每次在任务执行之后5秒执行下一次。
scheduledExecutorService.scheduleWithFixedDelay(() -> { System.out.println(Thread.currentThread()); }, 2, 5, TimeUnit.SECONDS);
// 逐个清除 idle 状态的线程
scheduledExecutorService.shutdown();
// 阻塞，在线程池被关调之前代码不再往下走
scheduledExecutorService.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);

3 使用线程池执行任务

前面提到，任务类型分为有返回值和无返回值的类型，这里的调用也分为有返回值调用和无返回值的调用。

3.1 无返回值任务的调用

如果是无返回值任务的调用，可以用execute或者submit方法，这种情况下二者本质上一样。为了于有返回值任务调用保持统一，建议采用submit方法。

//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(3);

//提交一个无返回值的任务（实现了Runnable接口）
executorService.submit(()->System.out.println("Hello"));

executorService.shutdown();
executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);

如果有一个任务集合，可以一个个提交。

//创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(3);
List<Runnable> tasks = Arrays.asList(
    ()->System.out.println("Hello"),
    ()->System.out.println("World"));

//逐个提交任务
tasks.forEach(executorService::submit);

executorService.shutdown();
executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);

3.2 有返回值任务的调用
有返回值的任务需要实现Callable接口，实现的时候在泛型位置指定返回值类型。在调用submit方法时会返回一个Future对象，通过Future的方法get()可以拿到返回值。这里需要注意的是，调用get()时代码会阻塞，直到任务完成，有返回值。

ExecutorService executorService = Executors.newFixedThreadPool(2);
Future<String> future = executorService.submit(()->"Hello");
System.out.println(future.isDone());//false
String value = future.get();
System.out.println(future.isDone());//true
System.out.println(value);//Hello

如果要提交一批任务，ExecutorService除了可以逐个提交之外，还可以调用invokeAll一次性提交，invokeAll的内部实现其实就是用一个循环逐个提交任务。invokeAll返回的值是一个Future List。

ExecutorService executorService = Executors.newFixedThreadPool(2);
List<Callable<String>> tasks = Arrays.asList(()->"Hello", ()->"World");
List<Future<String>> futures = executorService.invokeAll(tasks);

invokeAny方法也很有用，线程池执行若干个实现了Callable的任务，然后返回最先执行结束的任务的值，其它未完成的任务将被正常取消掉不会有异常。如下代码不会输出“Hello”

ExecutorService executorService = Executors.newFixedThreadPool(2);
List<Callable<String>> tasks = Arrays.asList(
    () -> {
      Thread.sleep(500L);
      System.out.println("Hello");
      return "Hello";
    }, () -> {
      System.out.println("World");
      return "World";
    });
String s = executorService.invokeAny(tasks);
System.out.println(s);//World

输出：

World
World

另外，在查看ExecutorService源码时发现它还提供了一个方法 Future submit(Runnable task, T result); ，可以通过这个方法提交一个实现了Runnable接口的任务，然后有返回值，而Runnable接口中的run方法时没有返回值的。那它的返回值是哪来的呢？其实问题在于该submit方法后面的一个参数，这个参数值就是返回的值。调用submit方法之后，有一通操作，然后直接把result参数返回了。

ExecutorService executorService = Executors.newFixedThreadPool(1);
Future<String> future = executorService.submit(() -> System.out.println("Hello"), "World");
System.out.println(future.get());//输出：World

在利用多线程处理任务时，应该根据情况选择合适的任务类型和线程池类型。如果无返回值，可以采用实现Runnable或Callable接口的任务；如果有返回值，应该使用实现Callable接口的任务，返回值通过Future的get方法取到。选用线程池时，如果只用1个线程，用单线程池或者容量为1的固定容量线程池；处理大量short-live任务是，使用可缓存的线程池；若要有计划或者循环执行某些任务，可以采用计划任务线程池；如果任务需要消耗大量的CPU资源，应用工作窃取线程池。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持

    public R<String> tgFx(){
        long b = System.currentTimeMillis();

        // 多线程开始 分析指标
        ThreadPoolExecutor executor = new ThreadPoolExecutor(8, 10, 200, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(2));
        Callable tk1 =()->{
            long l = System.currentTimeMillis();
            String res = tgBasicInfoService.addTgBasicInfoAll();
            long l1 = System.currentTimeMillis() - l;
            System.out.println("<<<====线程【1】执行完成  耗时"+ l1+ " 毫秒" );
            return 1;
        };

        Callable tk2 =()->{
            long l = System.currentTimeMillis();
            tgBasicInfoService.queryPoUserRap();
            long l1 = System.currentTimeMillis() - l;
            System.out.println("<<<====线程【2】执行完成  耗时"+ l1+ " 毫秒" );
            return 1;
        };

        Callable tk3 =()->{
            long l = System.currentTimeMillis();
            tgBasicInfoService.queryAllTg96Load();
            long l1 = System.currentTimeMillis() - l;
            System.out.println("<<<====线程【3】执行完成  耗时"+ l1+ " 毫秒" );
            return 2;
        };


        Callable tk4 =()->{
            long l = System.currentTimeMillis();
            tgBasicInfoService.insertExpansionTg();
            long l1 = System.currentTimeMillis() - l;
            System.out.println("<<<====线程【4】执行完成  耗时"+ l1+ " 毫秒" );
            return 2;
        };


        List tasks = new ArrayList<>();
        tasks.add(tk1);
        tasks.add(tk2);
        tasks.add(tk3);
        tasks.add(tk4);

        long l2 = System.currentTimeMillis();
        long d = l2 - b;

        try {
            executor.invokeAll(tasks);
            return R.data("++++++++++++++++计算完成+++++++++++++++耗时==>"+CalculateUtils.div(String.valueOf(d),"1000",2)+"秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
            return R.data(e.getMessage());
        }finally {
            executor.shutdown();
        }
    }

使用线程池执行多线程需要如下几个条件

首先是一个线程池，线程池包含一些初始化数据，包含队列大小，核心线程数，最大线程数。

然后是一个实现了 runnable的任务，将该任务当如到线程池中进行执行。

线程池配置：

public class ThreadPoolManager<T> {

    /**
     * 根据cpu的数量动态的配置核心线程数和最大线程数
     */
    private static final int CPU_COUNT         = Runtime.getRuntime().availableProcessors();

    /**
     * 核心线程数 = CPU核心数 + 1
     */
    private static final int CORE_POOL_SIZE    = CPU_COUNT + 1;

    /**
     * 线程池最大线程数 = CPU核心数 * 2 + 1
     */
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;

    /**
     * 非核心线程闲置时超时1s
     */
    private static final int KEEP_ALIVE        = 1;


    private ThreadPoolExecutor executor;



    private ThreadPoolManager() {

    }

    private static ThreadPoolManager sInstance;

    public synchronized static ThreadPoolManager getsInstance() {
        if (sInstance == null) {
            sInstance = new ThreadPoolManager();
        }
        return sInstance;
    }


    /**
     * 开启一个无返回值的线程
     * @param r
     */
    public void execute(Runnable r) {
        if (executor == null) {
            /**
             * corePoolSize:核心线程数
             * maximumPoolSize：线程池所容纳最大线程数(workQueue队列满了之后才开启)
             * keepAliveTime：非核心线程闲置时间超时时长
             * unit：keepAliveTime的单位
             * workQueue：等待队列，存储还未执行的任务
             * threadFactory：线程创建的工厂
             * handler：异常处理机制
             *
             */
            executor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE,
                    KEEP_ALIVE, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(1000),
                    Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        }
        // 把一个任务丢到了线程池中
        executor.execute(r);
    }

    /**
     * 开启一个有返回结果的线程
     * @param r
     * @return
     */
    public Future<T> submit(Callable<T> r) {
        if (executor == null) {
            /**
             * corePoolSize:核心线程数
             * maximumPoolSize：线程池所容纳最大线程数(workQueue队列满了之后才开启)
             * keepAliveTime：非核心线程闲置时间超时时长
             * unit：keepAliveTime的单位
             * workQueue：等待队列，存储还未执行的任务
             * threadFactory：线程创建的工厂
             * handler：异常处理机制
             *
             */
            executor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE,
                    KEEP_ALIVE, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(20),
                    Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        }
        // 把一个任务丢到了线程池中
        return executor.submit(r);
    }

    /**
     * 把任务移除等待队列
     * @param r
     */
    public void cancel(Runnable r) {
        if (r != null) {
            executor.getQueue().remove(r);
        }
    }

}

2. 然后 新建一个任务类，实现 runnable 接口，重写run方法

public class ConverterTask implements Runnable {

    


    @Override
    public void run() {
        //自己的业务逻辑，调用需要并发的方法
        //todo
    }
}

这样就可以简单的模拟一个线程池执行多线程的案例