博客

Java线程池的作用是什么？

  • Post category:Java

Java线程池的作用是什么？

线程池是Java多线程编程中非常重要的一个概念。线程池可以有效地管理、调度和复用多个线程，并减少线程的创建和销毁所带来的开销，提高应用程序的性能和稳定性。线程池一般由线程池管理器、工作队列和多个工作线程构成。

线程池的优点

  • 提高性能，减少线程的创建和销毁所带来的开销。
  • 提高稳定性，防止程序因创建大量线程而耗尽系统资源。
  • 提高可读性和可维护性，可以统一管理和调度多个线程。

线程池的使用步骤

Java线程池的使用步骤如下：

  1. 创建一个线程池对象，可以使用JDK提供的线程池工厂类（如Executors）的静态方法来创建线程池。
ExecutorService executorService = Executors.newFixedThreadPool(10);
  1. 创建一个任务对象，即实现Runnable或Callable接口的线程任务。
public class MyTask implements Runnable {
    @Override
    public void run() {
        // 线程任务的代码逻辑
    }
}
  1. 将任务提交到线程池中执行。
executorService.submit(new MyTask());
  1. 调用shutdown()方法关闭线程池。
executorService.shutdown();

线程池的相关参数

核心线程数

线程池中最小的可用线程数，如果当前线程数少于该值，会自动创建新的线程来处理任务。

ExecutorService executorService = Executors.newFixedThreadPool(10);

上面的代码中，核心线程数是10。

最大线程数

线程池中最大的可用线程数，如果当前线程数达到该值，会将多余的任务放入工作队列中等待。

ExecutorService executorService = new ThreadPoolExecutor(10, 20, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100));

上面的代码中，最大线程数是20。

工作队列

线程池用于存放等待执行的任务的队列，可以使用多种不同类型的队列，如ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue等。

ExecutorService executorService = new ThreadPoolExecutor(10, 20, 30, TimeUnit.SECONDS, new ArrayBlockingQueue<>(100));

上面的代码中，工作队列是一个可存放100个任务的ArrayBlockingQueue。

示例说明

下面给出两个示例说明线程池的使用方法。

示例一：使用FixedThreadPool来处理大量任务

下面的程序使用FixedThreadPool来创建一个线程池，然后提交1000个任务到线程池中，每个任务的执行时间是1秒钟。程序输出执行结果的时间并打印结果。

public class FixedThreadPoolExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        long start = System.currentTimeMillis();
        List<Future<Long>> futures = new ArrayList<>();
        for (int i = 0; i < 1000; i++) {
            final int j = i;
            Future<Long> future = executorService.submit(() -> {
                Thread.sleep(1000);
                return System.currentTimeMillis() - start;
            });
            futures.add(future);
        }
        for (Future<Long> future : futures) {
            System.out.println(future.get());
        }
        executorService.shutdown();
    }
}

程序输出的结果是1000行数字，每行数字表示任务执行的时间（单位是毫秒）。

示例二：使用CachedThreadPool来处理动态任务

下面的程序使用CachedThreadPool来创建一个线程池，然后提交一组任务到线程池中，每个任务的执行时间是2秒钟。程序创建一个定时任务，每隔1秒钟提交一个新的任务到线程池中，程序输出执行结果的时间并打印结果。

public class CachedThreadPoolExample {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        long start = System.currentTimeMillis();
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            private int count = 0;

            @Override
            public void run() {
                Future<Long> future = executorService.submit(() -> {
                    Thread.sleep(2000);
                    return System.currentTimeMillis() - start;
                });
                System.out.println("Task " + (++count) + " submitted at " + (System.currentTimeMillis() - start));
                try {
                    System.out.println("Task " + count + " result: " + future.get());
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }
            }
        }, 0, 1000);
        Thread.sleep(10000);
        timer.cancel();
        executorService.shutdown();
    }
}

程序输出的结果是一组数字，每个数字表示一个任务的执行时间（单位是毫秒）。由于程序会动态提交任务，因此每次运行的结果可能会不同。

Tags: