Java ExecutorService如何实现任务监控和日志记录

在Java中，使用ExecutorService可以方便地管理和控制线程池中的任务执行。为了实现任务监控和日志记录，可以采用以下几种方法：

1. 使用ThreadPoolExecutor的自定义扩展

ThreadPoolExecutor提供了一些钩子方法，可以在任务执行前后进行监控和日志记录。

import java.util.concurrent.*;

public class LoggingThreadPoolExecutor extends ThreadPoolExecutor {

    public LoggingThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue) {
        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
    }

    @Override
    protected void beforeExecute(Thread t, Runnable r) {
        super.beforeExecute(t, r);
        System.out.println("Task " + r.toString() + " is starting on thread " + t.getName());
    }

    @Override
    protected void afterExecute(Runnable r, Throwable t) {
        super.afterExecute(r, t);
        if (t == null && r instanceof java.util.concurrent.Future<?>) {
            try {
                java.util.concurrent.Future<?> future = (java.util.concurrent.Future<?>) r;
                if (future.isDone()) {
                    future.get();
                }
            } catch (CancellationException ce) {
                t = ce;
            } catch (ExecutionException ee) {
                t = ee.getCause();
            } catch (InterruptedException ie) {
                Thread.currentThread().interrupt(); // ignore/reset
            }
        }
        if (t != null) {
            System.out.println("Task " + r.toString() + " encountered an exception: " + t.getMessage());
        } else {
            System.out.println("Task " + r.toString() + " completed successfully");
        }
    }

    @Override
    protected void terminated() {
        super.terminated();
        System.out.println("ExecutorService has been terminated");
    }
}

2. 使用Future接口

通过提交任务并获取Future对象，可以在任务完成后进行日志记录。

import java.util.concurrent.*;

public class TaskMonitor {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        LoggingThreadPoolExecutor loggingExecutor = new LoggingThreadPoolExecutor(
                5, 10, 60L, TimeUnit.SECONDS, new LinkedBlockingQueue<>());

        Callable<String> task = () -> {
            System.out.println("Task is running");
            Thread.sleep(1000);
            return "Task completed";
        };

        Future<String> future = loggingExecutor.submit(task);

        try {
            String result = future.get();
            System.out.println("Result: " + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        loggingExecutor.shutdown();
    }
}

3. 使用ScheduledExecutorService进行定期监控

可以创建一个ScheduledExecutorService来定期检查任务的状态并进行日志记录。

import java.util.Map;
import java.util.concurrent.*;

public class ScheduledTaskMonitor {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        ScheduledExecutorService monitorService = Executors.newScheduledThreadPool(1);

        // Submit tasks to the executor service
        for (int i = 0; i < 10; i++) {
            executorService.submit(() -> {
                System.out.println("Task is running");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                System.out.println("Task completed");
            });
        }

        // Schedule a task to monitor the executor service
        monitorService.scheduleAtFixedRate(() -> {
            Map<Runnable, Future<?>> activeTasks = ((ThreadPoolExecutor) executorService).getActiveCount();
            System.out.println("Active tasks: " + activeTasks.size());
        }, 0, 5, TimeUnit.SECONDS);

        // Shutdown the executor service after some time
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        executorService.shutdown();
        monitorService.shutdown();
    }
}

通过这些方法，可以有效地监控ExecutorService中的任务执行情况，并记录相关的日志信息。