Java中线程池的创建方式有几种？

宋发元

已于 2024-06-25 14:34:38 修改

阅读量882

点赞数 30

文章标签： java python 开发语言

于 2024-06-25 14:20:43 首次发布

本文链接：https://blog.csdn.net/u011019141/article/details/139957788

版权

在Java中，线程池是一种用于管理多个线程的机制，旨在提高性能并简化多线程编程。Java提供了多种方式来创建和管理线程池，主要通过java.util.concurrent包中的ExecutorService接口和Executors类来实现。以下是几种常见的线程池创建方式：

1. 使用`Executors`类创建线程池

Executors类提供了一些静态工厂方法来创建常见的线程池类型：

a. Fixed Thread Pool

创建一个固定大小的线程池，当所有线程都在忙时，新任务会在队列中等待。

ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);

b. Cached Thread Pool

创建一个可缓存的线程池，适合执行很多短期异步任务。线程池根据需要创建新线程，空闲线程会在60秒后被终止和移除。

ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

c. Single Thread Executor

创建一个只有一个线程的线程池，确保所有任务按顺序执行。

ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

d. Scheduled Thread Pool

创建一个线程池，它可以在给定的延迟后或定期执行任务。

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);

2. 使用`ThreadPoolExecutor`类创建线程池

ThreadPoolExecutor是Java中最灵活的线程池实现，可以自定义线程池的行为。它提供了更多配置选项：

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

ThreadPoolExecutor customThreadPool = new ThreadPoolExecutor(
    4,                       // core pool size
    10,                      // maximum pool size
    60,                      // time to keep idle threads alive
    TimeUnit.SECONDS,        // time unit for keep alive time
    new LinkedBlockingQueue<Runnable>()  // work queue
);

3. 使用`ForkJoinPool`创建线程池

ForkJoinPool是Java 7引入的一个特殊的线程池，适合处理大量小任务的并行执行，尤其适合递归任务。

ForkJoinPool forkJoinPool = new ForkJoinPool();

线程池的关闭

无论使用哪种方式创建线程池，在完成任务后，应该关闭线程池以释放资源：

executorService.shutdown();  // 优雅地关闭，不接受新任务
executorService.shutdownNow();  // 强制关闭，试图终止当前正在执行的任务

线程池创建方式总结

Executors类：提供了方便的静态工厂方法来创建常见类型的线程池。
- newFixedThreadPool(int n): 固定大小线程池。
- newCachedThreadPool(): 可缓存的线程池。
- newSingleThreadExecutor(): 单线程池。
- newScheduledThreadPool(int corePoolSize): 定时线程池。
ThreadPoolExecutor类：提供了高度可配置的线程池实现，可以精细控制线程池的行为。
ForkJoinPool类：用于并行处理大量小任务，特别是递归任务。

根据应用程序的需求选择合适的线程池实现，可以显著提高性能并简化多线程编程。

案例

这里提供每种线程池的详细案例，帮助你理解它们的使用场景和方式。

1. Fixed Thread Pool

创建一个固定大小的线程池，适合有固定数量线程执行长期任务的场景。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);

        for (int i = 0; i < 10; i++) {
            final int taskNumber = i;
            fixedThreadPool.execute(() -> {
                System.out.println("Task " + taskNumber + " is running by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟任务执行
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        fixedThreadPool.shutdown();
    }
}

2. Cached Thread Pool

创建一个可缓存的线程池，适合执行大量短期任务。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

        for (int i = 0; i < 10; i++) {
            final int taskNumber = i;
            cachedThreadPool.execute(() -> {
                System.out.println("Task " + taskNumber + " is running by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟任务执行
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        cachedThreadPool.shutdown();
    }
}

3. Single Thread Executor

创建一个单线程池，适合需要保证任务顺序执行的场景。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SingleThreadExecutorExample {
    public static void main(String[] args) {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

        for (int i = 0; i < 10; i++) {
            final int taskNumber = i;
            singleThreadExecutor.execute(() -> {
                System.out.println("Task " + taskNumber + " is running by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟任务执行
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        singleThreadExecutor.shutdown();
    }
}

4. Scheduled Thread Pool

创建一个定时线程池，适合需要定时或周期性执行任务的场景。

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledThreadPoolExample {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);

        Runnable task = () -> {
            System.out.println("Scheduled task is running by " + Thread.currentThread().getName());
        };

        // 定时任务，延迟2秒后执行
        scheduledThreadPool.schedule(task, 2, TimeUnit.SECONDS);

        // 周期性任务，延迟1秒后每3秒执行一次
        scheduledThreadPool.scheduleAtFixedRate(task, 1, 3, TimeUnit.SECONDS);

        // 允许一些时间让任务执行
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        scheduledThreadPool.shutdown();
    }
}

5. ThreadPoolExecutor

创建一个自定义的线程池，适合需要精细控制线程池行为的场景。

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class CustomThreadPoolExample {
    public static void main(String[] args) {
        ThreadPoolExecutor customThreadPool = new ThreadPoolExecutor(
            4,                       // core pool size
            10,                      // maximum pool size
            60,                      // time to keep idle threads alive
            TimeUnit.SECONDS,        // time unit for keep alive time
            new LinkedBlockingQueue<Runnable>()  // work queue
        );

        for (int i = 0; i < 10; i++) {
            final int taskNumber = i;
            customThreadPool.execute(() -> {
                System.out.println("Task " + taskNumber + " is running by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(1000); // 模拟任务执行
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        customThreadPool.shutdown();
    }
}

6. ForkJoinPool

创建一个适合并行处理大量小任务的线程池，特别是递归任务。

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class ForkJoinPoolExample {
    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        try {
            FibonacciTask task = new FibonacciTask(10);
            Integer result = forkJoinPool.invoke(task);
            System.out.println("Fibonacci result: " + result);
        } finally {
            forkJoinPool.shutdown();
        }
    }

    static class FibonacciTask extends RecursiveTask<Integer> {
        private final int n;

        FibonacciTask(int n) {
            this.n = n;
        }

        @Override
        protected Integer compute() {
            if (n <= 1) {
                return n;
            }
            FibonacciTask f1 = new FibonacciTask(n - 1);
            FibonacciTask f2 = new FibonacciTask(n - 2);
            f1.fork(); // 异步执行
            return f2.compute() + f1.join(); // 合并结果
        }
    }
}

这些示例展示了不同类型线程池的使用方式，根据不同的需求选择合适的线程池类型，可以帮助优化多线程程序的性能和管理复杂度。

宋发元

关注

30
点赞
踩
9

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java中线程池的创建方式有几种？

Executors类：提供了方便的静态工厂方法来创建常见类型的线程池。: 固定大小线程池。: 可缓存的线程池。: 单线程池。: 定时线程池。类：提供了高度可配置的线程池实现，可以精细控制线程池的行为。类：用于并行处理大量小任务，特别是递归任务。根据应用程序的需求选择合适的线程池实现，可以显著提高性能并简化多线程编程。
复制链接

扫一扫