【Java多线程】6 Java 中的线程池-优快云博客

本文链接：https://blog.youkuaiyun.com/A1924/article/details/143357458

Java 中的线程池

线程池是一种通过管理一组线程来提高多线程程序性能的技术。通过使用线程池，我们可以减少线程创建和销毁的开销，提高资源的利用率，并实现线程复用。Java 提供了 java.util.concurrent 包中的 Executor 框架来创建和管理线程池。

一、线程池的优势

减少线程创建的开销：重用线程，避免频繁创建和销毁线程。
控制最大并发线程数：避免因线程过多导致的系统资源耗尽。
提高资源利用率：通过复用线程，提高 CPU 和内存的利用效率。
简化线程管理：通过使用线程池接口简化多线程程序的管理。

二、线程池的基本接口

Java 的线程池主要由以下几个接口组成：

Executor：执行任务的接口，包含 execute(Runnable command) 方法。
ExecutorService：扩展了 Executor，提供了管理生命周期和获取结果的方法。
ScheduledExecutorService：支持定时和周期性任务执行的接口。

三、创建线程池

Java 提供了 Executors 工厂类，方便我们创建各种类型的线程池。

3.1 固定大小线程池

使用 Executors.newFixedThreadPool(int nThreads) 创建一个固定大小的线程池。

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

public class FixedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3); // 创建一个固定大小为3的线程池

        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("任务 " + taskId + " 正在 " + Thread.currentThread().getName() + " 中运行");
                try {
                    Thread.sleep(1000); // 模拟任务
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown(); // 关闭线程池
    }
}

3.2 可缓存线程池

使用 Executors.newCachedThreadPool() 创建一个可缓存的线程池，可以根据需要创建新线程，当线程空闲时会被回收。

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

public class CachedThreadPoolExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool(); // 创建可缓存的线程池

        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("任务 " + taskId + " 正在 " + Thread.currentThread().getName() + " 中运行");
                try {
                    Thread.sleep(1000); // 模拟任务
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        executor.shutdown(); // 关闭线程池
    }
}

3.3 定时任务线程池

使用 Executors.newScheduledThreadPool(int corePoolSize) 创建一个可以执行定时和周期性任务的线程池。

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 executor = Executors.newScheduledThreadPool(2); // 创建一个定时任务线程池

        executor.schedule(() -> System.out.println("延迟任务已执行！"), 3, TimeUnit.SECONDS); // 延迟3秒执行

        executor.scheduleAtFixedRate(() -> {
            System.out.println("重复任务已执行！");
        }, 0, 2, TimeUnit.SECONDS); // 每2秒执行一次

        // 运行一段时间后关闭线程池
        try {
            Thread.sleep(10000); // 等待10秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown(); // 关闭线程池
        }
    }
}

四、处理任务结果

如果任务需要返回结果，可以使用 Callable 接口和 Future 类。

示例代码

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class CallableExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(3);

        Future<Integer> future = executor.submit(new Callable<Integer>() {
            @Override
            public Integer call() {
                // 执行任务，返回结果
                return 123;
            }
        });

        try {
            Integer result = future.get(); // 获取任务结果
            System.out.println("结果: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown(); // 关闭线程池
        }
    }
}