blocks|key|4540168|text|我认为你这个相当优雅的想法的主要问题是，你只是在Future的get上超时，一旦它超时，你实际上不会中止进程，你只是放弃等待它。当你意识到你甚至可能在进程还没有启动的时候就超时了，这个问题就变得更加复杂了--它只是在队列中。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4540169|也许像这样的东西会很有效。它确实需要两个线程，但一个TimerTask线程应该消耗很少。|4540170|public+class+RunWithTimeout+{

++++public+RunWithTimeout(Runnable+r,+long+timeout)+{
++++++++//+Prepare+the+thread.
++++++++final+Thread+t+=+new+Thread(r);
++++++++//+Start+the+timer.
++++++++new+Timer(true).schedule(new+TimerTask()+{

++++++++++++@Override
++++++++++++public+void+run()+{
++++++++++++++++if+(t.isAlive())+{
++++++++++++++++++++//+Abort+the+thread.
++++++++++++++++++++t.interrupt();
++++++++++++++++}
++++++++++++}
++++++++},+timeout+*+1000);
++++++++//+Start+the+thread.
++++++++t.start();
++++}

}

class+WaitAFewSeconds+implements+Runnable+{

++++final+long+seconds;

++++WaitAFewSeconds(long+seconds)+{
++++++++this.seconds+=+seconds;
++++}

++++@Override
++++public+void+run()+{
++++++++try+{
++++++++++++Thread.sleep(seconds+*+1000);
++++++++}+catch+(InterruptedException+ie)+{
++++++++++++System.out.println("WaitAFewSeconds("+%2B+seconds+%2B+")+-+Interrupted!");
++++++++}
++++}

}

public+void+test()+{
++++new+RunWithTimeout(new+WaitAFewSeconds(5),+3);
++++new+RunWithTimeout(new+WaitAFewSeconds(3),+5);
}|code-block|syntax|javascript|4540171|这里有一个替代方案，只使用一个额外的线程。|4540172|public+class+ThreadKiller+implements+Runnable+{

++++DelayQueue<WaitForDeath>+kill+=+new+DelayQueue<>();

++++private+class+WaitForDeath+implements+Delayed+{

++++++++final+Thread+t;
++++++++final+long+finish;

++++++++public+WaitForDeath(Thread+t,+long+wait)+{
++++++++++++this.t+=+t;
++++++++++++this.finish+=+System.currentTimeMillis()+%2B+wait;
++++++++}

++++++++@Override
++++++++public+long+getDelay(TimeUnit+unit)+{
++++++++++++return+unit.convert(finish+-+System.currentTimeMillis(),+TimeUnit.MILLISECONDS);
++++++++}

++++++++@Override
++++++++public+int+compareTo(Delayed+o)+{
++++++++++++long+itsFinish+=+((WaitForDeath)+o).finish;
++++++++++++return+finish+<+itsFinish+?+-1+:+finish+==+itsFinish+?+0+:+1;
++++++++}

++++}

++++@Override
++++public+void+run()+{
++++++++while+(true)+{
++++++++++++try+{
++++++++++++++++WaitForDeath+t+=+kill.take();
++++++++++++++++if+(t.t.isAlive())+{
++++++++++++++++++++//+Interrupt+it.
++++++++++++++++++++t.t.interrupt();
++++++++++++++++}
++++++++++++}+catch+(InterruptedException+ex)+{
++++++++++++++++//+Not+sure+what+to+do+here.
++++++++++++}
++++++++}
++++}

++++public+void+registerThread(Thread+t,+long+wait)+{
++++++++//+Post+it+into+the+delay+queue.
++++++++kill.add(new+WaitForDeath(t,+wait));
++++}
}

public+void+test()+throws+InterruptedException+{
++++//+Testing+the+ThreadKiller.
++++ThreadKiller+killer+=+new+ThreadKiller();
++++Thread+killerThread+=+new+Thread(killer);
++++killerThread.setDaemon(true);
++++Thread+twoSeconds+=+new+Thread(new+WaitAFewSeconds(2));
++++Thread+fourSeconds+=+new+Thread(new+WaitAFewSeconds(4));
++++killer.registerThread(twoSeconds,+5000);
++++killer.registerThread(fourSeconds,+3000);
++++killerThread.start();
++++twoSeconds.start();
++++fourSeconds.start();
++++System.out.println("Waiting");
++++Thread.sleep(10+*+1000);
++++System.out.println("Finished");
++++killerThread.interrupt();
}|4540173|entityMap^0|O|6|V|3|0|Q|9|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|12|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|R|$]]

I think your primary problem with this rather elegant idea is that you are only timing out on the <code>get</code> of the <code>Future</code>, you are not actually aborting the process once it times out, you are just giving up waiting for it. The issue becomes even more complex when you realise that you may even time out when the process hasn't even started - it is just still in the queue.

Perhaps something like this would be effective. It does require two threads but a <code>TimerTask</code> thread should consume very little.

<pre><code>public class RunWithTimeout {

 public RunWithTimeout(Runnable r, long timeout) {
 // Prepare the thread.
 final Thread t = new Thread(r);
 // Start the timer.
 new Timer(true).schedule(new TimerTask() {

 @Override
 public void run() {
 if (t.isAlive()) {
 // Abort the thread.
 t.interrupt();
 }
 }
 }, timeout * 1000);
 // Start the thread.
 t.start();
 }

}

class WaitAFewSeconds implements Runnable {

 final long seconds;

 WaitAFewSeconds(long seconds) {
 this.seconds = seconds;
 }

 @Override
 public void run() {
 try {
 Thread.sleep(seconds * 1000);
 } catch (InterruptedException ie) {
 System.out.println("WaitAFewSeconds(" + seconds + ") - Interrupted!");
 }
 }

}

public void test() {
 new RunWithTimeout(new WaitAFewSeconds(5), 3);
 new RunWithTimeout(new WaitAFewSeconds(3), 5);
}
</code></pre>

Here's an alternative that only uses one extra thread.

<pre><code>public class ThreadKiller implements Runnable {

 DelayQueue&lt;WaitForDeath&gt; kill = new DelayQueue&lt;&gt;();

 private class WaitForDeath implements Delayed {

 final Thread t;
 final long finish;

 public WaitForDeath(Thread t, long wait) {
 this.t = t;
 this.finish = System.currentTimeMillis() + wait;
 }

 @Override
 public long getDelay(TimeUnit unit) {
 return unit.convert(finish - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
 }

 @Override
 public int compareTo(Delayed o) {
 long itsFinish = ((WaitForDeath) o).finish;
 return finish &lt; itsFinish ? -1 : finish == itsFinish ? 0 : 1;
 }

 }

 @Override
 public void run() {
 while (true) {
 try {
 WaitForDeath t = kill.take();
 if (t.t.isAlive()) {
 // Interrupt it.
 t.t.interrupt();
 }
 } catch (InterruptedException ex) {
 // Not sure what to do here.
 }
 }
 }

 public void registerThread(Thread t, long wait) {
 // Post it into the delay queue.
 kill.add(new WaitForDeath(t, wait));
 }
}

public void test() throws InterruptedException {
 // Testing the ThreadKiller.
 ThreadKiller killer = new ThreadKiller();
 Thread killerThread = new Thread(killer);
 killerThread.setDaemon(true);
 Thread twoSeconds = new Thread(new WaitAFewSeconds(2));
 Thread fourSeconds = new Thread(new WaitAFewSeconds(4));
 killer.registerThread(twoSeconds, 5000);
 killer.registerThread(fourSeconds, 3000);
 killerThread.start();
 twoSeconds.start();
 fourSeconds.start();
 System.out.println("Waiting");
 Thread.sleep(10 * 1000);
 System.out.println("Finished");
 killerThread.interrupt();
}
</code></pre>

blocks|key|32607|text|当线程运行时，你需要启动计时器。那么处于等待状态的线程都不会被杀死。以下是来自this+thread的示例|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|32608|import+java.util.Timer;
import+java.util.TimerTask;
import+java.util.concurrent.ExecutorService;
import+java.util.concurrent.Executors;

public+class+PoolTest+{
++++class+TimeOutTask+extends+TimerTask+{
++++++++Thread+t;

++++++++TimeOutTask(Thread+t)+{
++++++++++++this.t+=+t;
++++++++}

++++++++public+void+run()+{
++++++++++++if+(t+!=+null+&&+t.isAlive())+{
++++++++++++++++t.interrupt();
++++++++++++}
++++++++}
++++}

++++class+MyRunnable+implements+Runnable+{
++++++++Timer+timer+=+new+Timer(true);

++++++++public+void+run()+{
++++++++++++timer.schedule(new+TimeOutTask(Thread.currentThread()),+1000);
++++++++++++try+{
++++++++++++++++System.out.println("MyRunnable...");
++++++++++++++++Thread.sleep(10000);
++++++++++++}+catch+(InterruptedException+ie)+{
++++++++++++++++System.out.println("MyRunnable+error...");
++++++++++++++++ie.printStackTrace();
++++++++++++}
++++++++}
++++}

++++public+static+void+main(String+args[])+{
++++++++new+PoolTest();
++++}

++++public+PoolTest()+{
++++++++try+{
++++++++++++ExecutorService+pe+=+Executors.newFixedThreadPool(3);
++++++++++++pe.execute(new+MyRunnable());
++++++++}+catch+(Exception+e)+{
++++++++++++e.printStackTrace();
++++++++}
++++}
}|code-block|syntax|javascript|32609|entityMap|0|LINK|mutability|MUTABLE|url|http://groups.google.com.br/group/comp.lang.java.programmer/msg/0fea9dd5f0117a7f^0|13|B|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

You need to start timer when the thread runs. Then no thread in waiting state will be killed. Here is the sample from <a href="http://groups.google.com.br/group/comp.lang.java.programmer/msg/0fea9dd5f0117a7f" rel="nofollow noreferrer">this thread</a>:

<pre><code>import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class PoolTest {
 class TimeOutTask extends TimerTask {
 Thread t;

 TimeOutTask(Thread t) {
 this.t = t;
 }

 public void run() {
 if (t != null &amp;&amp; t.isAlive()) {
 t.interrupt();
 }
 }
 }

 class MyRunnable implements Runnable {
 Timer timer = new Timer(true);

 public void run() {
 timer.schedule(new TimeOutTask(Thread.currentThread()), 1000);
 try {
 System.out.println("MyRunnable...");
 Thread.sleep(10000);
 } catch (InterruptedException ie) {
 System.out.println("MyRunnable error...");
 ie.printStackTrace();
 }
 }
 }

 public static void main(String args[]) {
 new PoolTest();
 }

 public PoolTest() {
 try {
 ExecutorService pe = Executors.newFixedThreadPool(3);
 pe.execute(new MyRunnable());
 } catch (Exception e) {
 e.printStackTrace();
 }
 }
}
</code></pre>

In a web server i wrote, each request invokes a list of actions. Some of these actions aren't as critical as others, so I would like to run them in a background thread.

Also, since they aren't that important I don't care if one of them fails seldomly, and I don't want them to take up a thread forever, so other threads would be available to process the next batch.

So, I would like to have a thread pool (e.g.: 10 threads) and hand out a thread to each background task like this. Limit each thread to 1 second, and if it doesn't finish by that time, just kill it, and be available for the next task to come in.

How would I go about doing this ?

So far, this is what I have :

<pre><code>public class AsyncCodeRunner {

 private static final ExecutorService executor = Executors.newFixedThreadPool(10);

 public void Run(Callable&lt;Void&gt; callableCode, int timeout) {

 final int threadTimeout = 10;
 Future&lt;Void&gt; callableFuture = executor.submit(callableCode);

 try {
 callableFuture.get(threadTimeout, TimeUnit.SECONDS);
 } catch (Exception e) {
 logger.Info("Thread was timed out", e);
 }
 }
}
</code></pre>

And I want to use this class like this :

<pre><code>public void processRequest(RequestObject request) {

 // do some important processing

 // throw some less important processing to background thread
 (new AsyncCodeRunner()).Run(new Callable&lt;Void&gt; () {
 @Override
 public Void call() throws Exception {
 // do something...
 return null;
 }
 }, 1); // 1 second timeout

 // return result (without waiting for background task)
 return;

}
</code></pre>

Will this work like I want it to ? Or how should I change it so it would ? 
And what happens if I call <code>Run()</code> but there are no available threads in the threadpool to hand out ?

Running asynchronous code in java with timeout

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

在我编写的web服务器中，每个请求都会调用一个操作列表。其中一些操作并不像其他操作那样关键，所以我想在后台线程中运行它们。此外，由于它们不是那么重要，我不关心它们中的一个是否会罕见地失败，我也不希望它们永远占用一个线程，所以其他线程将可用于处理下一批处理。因此，我希望有一个线程池(例如: 10个线程)，并像这样向每个后...

问在java中运行带超时的异步代码
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在java中运行带超时的异步代码EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在java中运行带超时的异步代码
EN