Java ThreadPoolExecutor超时配置

我想为我的ThreadPoolExecutor设置一个超时

我知道我可以用

future.get(THREAD_TIMEOUT_MS, TimeUnit.MILLISECONDS);

但是这个代码是阻塞的

我想要实现的是，我可以创建几个Runables，这些Runables使用一个由4个线程组成的池进行处理

如果线程的处理时间超过5秒，我想抛出超时异常

这是我当前的设置：

public class ServerExecutorService {

    public static int QUEUE_KEEP_ALIVE_TIME_SECONDS = 5;
    public static int MAXIMUM_POOL_SIZE = 12;
    public static int CORE_POOL_SIZE = 12;
    public static Logger LOG = LoggerFactory.getLogger(ServerExecutorService .class);
    public static int THREAD_TIMEOUT_MS = 5000;
    private LinkedBlockingQueue linkedBlockingQueue = new LinkedBlockingQueue(2);
    private RejectedHandler rejectedHandler = new RejectedHandler();


    private ThreadPoolExecutor executor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, QUEUE_KEEP_ALIVE_TIME_SECONDS, TimeUnit.SECONDS, linkedBlockingQueue);

    public ServerExecutorService () {
        executor.setRejectedExecutionHandler(this.rejectedHandler);
    }

    public void setRejectedHandler(RejectedHandler rejectedHandler) {
        executor.setRejectedExecutionHandler(rejectedHandler);
    }


    public void execute(Runnable runnable){
//        executor.execute(runnable);
//        Future<?> future = executor.submit(runnable);
        Future<?> future = executor.submit(runnable);

        try {
            future.get(THREAD_TIMEOUT_MS, TimeUnit.MILLISECONDS);
        } catch (TimeoutException e) {
            System.out.println("Thread processing timeout.");
            LOG.warn("Thread processing timeout.", e);
        } catch (Exception e) {
            System.out.println("Thread processing error within ServerExecutorService ");
            LOG.error("Thread processing error within ServerExecutorService ", e);
        }
    }

}

公共类服务器执行器服务{
公共静态整数队列\u保持活动\u时间\u秒=5；
公共静态int最大池大小=12；
公共静态int核心池大小=12；
公共静态记录器LOG=LoggerFactory.getLogger（ServerExecutorService.class）；
公共静态int线程\u超时\u MS=5000；
私有LinkedBlockingQueue LinkedBlockingQueue=新LinkedBlockingQueue（2）；
private RejectedHandler RejectedHandler=新RejectedHandler（）；
private ThreadPoolExecutor executor=新的ThreadPoolExecutor（核心池大小、最大池大小、队列保持活动、时间秒、时间单位秒、linkedBlockingQueue）；
公共服务（）{
executor.setRejectedExecutionHandler（this.rejectedHandler）；
}
public void setRejectedHandler（RejectedHandler RejectedHandler）{
executor.setRejectedExecutionHandler（rejectedHandler）；
}
public void execute（可运行可运行）{
//执行器。执行（可运行）；
//Future=executor.submit（可运行）；
Future=executor.submit（可运行）；
试一试{
get（线程超时毫秒，时间单位毫秒）；
}捕获（超时异常e）{
System.out.println（“线程处理超时”）；
LOG.warn（“线程处理超时”，e）；
}捕获（例外e）{
System.out.println（“ServerExecutorService中的线程处理错误”）；
LOG.error（“ServerExecutorService内的线程处理错误”，e）；
}
}
}

但是就像你可以看到未来一样。get（THREAD\u TIMEOUT\u MS，TimeUnit.MS）；将等待线程完成。因此，下一个线程不会启动

测试：

@测试
public void testthreadpooldefined（）{
serverExecutorService.setRejectedHandler（rejectedHandler）；
对于（int i=0；i<4；i++）{
最终int finalI=i；
serverExecutorService.execute（新的Runnable（）{
@凌驾
公开募捐{
试一试{
System.out.println（“做点什么”+finalI）；
睡眠（3000）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
});
}
}

---

在此测试中，第二个线程在3秒后启动，而不是立即启动。

您可以创建两个线程池，一个用于超时，另一个用于实际工作

ExecutorService timeoutService = Executors.newCachedThreadPool();
ExecutorService workerService = Executors.newCachedThreadPool();

public Future<?> submit(final Runnable runnable){
    return timeoutService.submit(() -> {
        try {
            Future<?> future = workerService.submit(runnable);
            future.get(100, TimeUnit.MILLISECONDS);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    });
}

ExecutorService timeoutService=Executors.newCachedThreadPool（）；
ExecutorService workerService=Executors.newCachedThreadPool（）；
公共未来提交（最终可运行）{
return timeoutService.submit（（）->{
试一试{
Future=workerService.submit（可运行）；
get（100，时间单位毫秒）；
}捕获（例外e）{
抛出新的运行时异常（e）；
}
});
}

当然这是意料之中的，因为ServerExecutorService在将来被阻止。get（）方法反过来又取决于关联线程的返回状态。是否要立即启动第二个线程？是。这就是我想要的。你最好在超时后取消你的任务。我只能在达到超时时取消。但是如何设置超时？

ExecutorService timeoutService = Executors.newCachedThreadPool();
ExecutorService workerService = Executors.newCachedThreadPool();

public Future<?> submit(final Runnable runnable){
    return timeoutService.submit(() -> {
        try {
            Future<?> future = workerService.submit(runnable);
            future.get(100, TimeUnit.MILLISECONDS);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    });
}