Java单线程池案例如何编写

本文目录导读：

1. 基础单线程池示例
2. 带返回结果的单线程池
3. 任务队列管理示例
4. 实际应用：订单处理系统
5. 异常处理示例

我来介绍几种Java单线程池的常见编写案例。

基础单线程池示例

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class SingleThreadPoolExample {
    public static void main(String[] args) {
        // 创建单线程池
        ExecutorService executor = Executors.newSingleThreadExecutor();
        // 提交任务
        for (int i = 1; i <= 5; i++) {
            final int taskId = i;
            executor.submit(() -> {
                System.out.println("任务 " + taskId + " 开始执行，线程: " + 
                                 Thread.currentThread().getName());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("任务 " + taskId + " 执行完成");
            });
        }
        // 关闭线程池
        executor.shutdown();
    }
}

带返回结果的单线程池

import java.util.concurrent.*;
public class SingleThreadPoolWithResult {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        // 提交带返回值的任务
        Future<String> future = executor.submit(() -> {
            Thread.sleep(2000);
            return "任务执行结果：" + System.currentTimeMillis();
        });
        System.out.println("等待任务执行...");
        // 获取结果（会阻塞直到任务完成）
        String result = future.get();
        System.out.println("获取到结果：" + result);
        executor.shutdown();
    }
}

任务队列管理示例

import java.util.concurrent.*;
import java.util.*;
public class TaskQueueManagement {
    public static void main(String[] args) throws InterruptedException {
        // 自定义线程工厂
        ThreadFactory threadFactory = new ThreadFactory() {
            private int count = 0;
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName("单线程池-任务-" + (++count));
                thread.setDaemon(false);
                return thread;
            }
        };
        // 使用自定义线程工厂创建单线程池
        ExecutorService executor = Executors.newSingleThreadExecutor(threadFactory);
        // 提交多个任务
        for (int i = 1; i <= 3; i++) {
            final int taskId = i;
            executor.execute(() -> {
                System.out.println("任务" + taskId + " 开始");
                // 模拟耗时操作
                for (int j = 0; j < 5; j++) {
                    System.out.println("任务" + taskId + " 执行中...步骤" + (j+1));
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("任务" + taskId + " 完成");
            });
        }
        // 优雅关闭
        executor.shutdown();
        // 等待所有任务完成
        if (executor.awaitTermination(10, TimeUnit.SECONDS)) {
            System.out.println("所有任务执行完毕");
        } else {
            System.out.println("任务未在指定时间内完成");
        }
    }
}

实际应用：订单处理系统

import java.util.concurrent.*;
import java.util.*;
public class OrderProcessingSystem {
    private final ExecutorService executor = Executors.newSingleThreadExecutor();
    private final Queue<String> pendingOrders = new ConcurrentLinkedQueue<>();
    // 添加订单
    public void addOrder(String orderId) {
        pendingOrders.offer(orderId);
        executor.submit(() -> processOrder(orderId));
    }
    // 处理订单
    private void processOrder(String orderId) {
        System.out.println("开始处理订单: " + orderId + 
                         " [线程: " + Thread.currentThread().getName() + "]");
        try {
            // 模拟订单处理步骤
            Thread.sleep(1000);
            System.out.println("订单 " + orderId + " - 步骤1: 验证完成");
            Thread.sleep(1000);
            System.out.println("订单 " + orderId + " - 步骤2: 支付处理");
            Thread.sleep(1000);
            System.out.println("订单 " + orderId + " - 步骤3: 库存更新");
            System.out.println("订单 " + orderId + " 处理完成！");
        } catch (InterruptedException e) {
            System.err.println("订单 " + orderId + " 处理被中断");
        }
    }
    // 获取待处理订单数量
    public int getPendingOrderCount() {
        return pendingOrders.size();
    }
    // 关闭系统
    public void shutdown() {
        executor.shutdown();
        try {
            if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                executor.shutdownNow();
            }
        } catch (InterruptedException e) {
            executor.shutdownNow();
        }
    }
    public static void main(String[] args) {
        OrderProcessingSystem system = new OrderProcessingSystem();
        // 模拟添加多个订单
        for (int i = 1; i <= 3; i++) {
            String orderId = "ORD-" + System.currentTimeMillis();
            system.addOrder(orderId);
            System.out.println("已添加订单: " + orderId);
        }
        // 等待一段时间后关闭系统
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        system.shutdown();
    }
}

异常处理示例

import java.util.concurrent.*;
public class ExceptionHandlingExample {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        // 方法1: 使用try-catch在任务内部处理异常
        executor.submit(() -> {
            try {
                System.out.println("任务1开始");
                int result = 10 / 0; // 模拟异常
            } catch (Exception e) {
                System.err.println("任务1出现异常: " + e.getMessage());
            }
        });
        // 方法2: 使用Future捕获异常
        Future<Integer> future = executor.submit(() -> {
            System.out.println("任务2开始");
            return 10 / 0; // 模拟异常
        });
        try {
            Integer result = future.get();
            System.out.println("任务2结果: " + result);
        } catch (ExecutionException e) {
            System.err.println("捕获到任务2的异常: " + e.getCause().getMessage());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 方法3: 使用UncaughtExceptionHandler
        ThreadFactory threadFactory = r -> {
            Thread t = new Thread(r);
            t.setUncaughtExceptionHandler((thread, e) -> 
                System.err.println("未捕获异常: " + e.getMessage()));
            return t;
        };
        ExecutorService executor2 = Executors.newSingleThreadExecutor(threadFactory);
        executor2.submit(() -> {
            System.out.println("任务3开始");
            throw new RuntimeException("任务3的运行时异常");
        });
        executor.shutdown();
        executor2.shutdown();
    }
}

1. 任务顺序执行：所有任务按提交顺序依次执行
2. 线程复用：只创建一个线程，所有任务共享
3. 任务队列：使用无界LinkedBlockingQueue存储等待任务
4. 优雅关闭：支持shutdown()和shutdownNow()方法

使用建议：

• 适合需要保证任务执行顺序的场景
• 避免在单线程池中执行长时间阻塞操作
• 注意异常处理,防止线程异常终止
• 合理设置超时时间,避免线程池无法关闭