blocks|key|1283191|text|您可以使用Executor：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283192|ExecutorService+executor+=+Executors.newCachedThreadPool();
Callable<Object>+task+=+new+Callable<Object>()+{
+++public+Object+call()+{
++++++return+something.blockingMethod();
+++}
};
Future<Object>+future+=+executor.submit(task);
try+{
+++Object+result+=+future.get(5,+TimeUnit.SECONDS);+
}+catch+(TimeoutException+ex)+{
+++//+handle+the+timeout
}+catch+(InterruptedException+e)+{
+++//+handle+the+interrupts
}+catch+(ExecutionException+e)+{
+++//+handle+other+exceptions
}+finally+{
+++future.cancel(true);+//+may+or+may+not+desire+this
}|code-block|syntax|javascript|1283193|如果future.get在5秒内没有返回，它将抛出一个TimeoutException。超时可以配置为秒、分、毫秒或TimeUnit中作为常量提供的任何单位。|offset|length|style|CODE|1283194|有关更多详细信息，请参阅JavaDoc。|1283195|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Future.html^0|0|0|2|A|R|G|1M|8|0|C|7|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@$I|Z|J|10|K|L]|$I|11|J|12|K|L]|$I|13|J|14|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@$I|16|J|17|1|18]]|A|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

You could use an Executor:

<pre><code>ExecutorService executor = Executors.newCachedThreadPool();
Callable&lt;Object&gt; task = new Callable&lt;Object&gt;() {
 public Object call() {
 return something.blockingMethod();
 }
};
Future&lt;Object&gt; future = executor.submit(task);
try {
 Object result = future.get(5, TimeUnit.SECONDS); 
} catch (TimeoutException ex) {
 // handle the timeout
} catch (InterruptedException e) {
 // handle the interrupts
} catch (ExecutionException e) {
 // handle other exceptions
} finally {
 future.cancel(true); // may or may not desire this
}
</code></pre>

If the <code>future.get</code> doesn't return in 5 seconds, it throws a <code>TimeoutException</code>. The timeout can be configured in seconds, minutes, milliseconds or any unit available as a constant in <code>TimeUnit</code>.

See the <a href="https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Future.html" rel="noreferrer">JavaDoc</a> for more detail.

blocks|key|1283111|text|您可以将调用包装在FutureTask中，并使用get()的超时版本。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1283112|请参阅http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/FutureTask.html|1283113|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/FutureTask.html^0|9|A|0|3|24|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@$9|T|A|U|1|V]]|E|$]]|$1|H|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

You could wrap the call in a <code>FutureTask</code> and use the timeout version of get().

See <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/FutureTask.html" rel="noreferrer">http://java.sun.com/j2se/1.5.0/docs/api/java/util/concurrent/FutureTask.html</a>

blocks|key|1498110|text|另请参阅Guava的TimeLimiter，它在幕后使用了一个执行器。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1498111|entityMap|0|LINK|mutability|MUTABLE|url|https://guava.dev/releases/22.0/api/docs/com/google/common/util/concurrent/TimeLimiter.html^0|A|B|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

See also Guava's <a href="https://guava.dev/releases/22.0/api/docs/com/google/common/util/concurrent/TimeLimiter.html" rel="nofollow noreferrer">TimeLimiter</a> which uses an Executor behind the scenes.

blocks|key|1498243|text|对于这个问题，还有一个使用jcabi-aspects库的AspectJ解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1498244|@Timeable(limit+=+30,+unit+=+TimeUnit.MINUTES)
public+Soup+cookSoup()+{
++//+Cook+soup,+but+for+no+more+than+30+minutes+(throw+and+exception+if+it+takes+any+longer
}|code-block|syntax|javascript|1498245|当然，它不能再简洁了，但您必须依赖于AspectJ，并在构建生命周期中引入它。|1498246|有一篇文章对此做了进一步的解释：Limit+Java+Method+Execution+Time|1498247|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/jcabi/jcabi-aspects|1|http://www.yegor256.com/2014/06/20/limit-method-execution-time.html^0|D|D|0|0|0|0|G|W|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|11|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|12|8|@]|9|@$A|13|B|14|1|15]]|C|$]]|$1|M|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]]]

There is also an AspectJ solution for that with <a href="https://github.com/jcabi/jcabi-aspects" rel="nofollow">jcabi-aspects</a> library. 

<pre><code>@Timeable(limit = 30, unit = TimeUnit.MINUTES)
public Soup cookSoup() {
 // Cook soup, but for no more than 30 minutes (throw and exception if it takes any longer
}
</code></pre>

It can't get more succinct, but you have to depend on AspectJ and introduce it in your build lifecycle, of course.

There is an article explaining it further: <a href="http://www.yegor256.com/2014/06/20/limit-method-execution-time.html" rel="nofollow">Limit Java Method Execution Time</a>

blocks|key|1498362|text|我在这里给你完整的代码。代替我调用的方法，您可以使用您的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1498363|public+class+NewTimeout+{
++++public+String+simpleMethod()+{
++++++++return+"simple+method";
++++}

++++public+static+void+main(String[]+args)+{
++++++++ExecutorService+executor+=+Executors.newSingleThreadScheduledExecutor();
++++++++Callable<Object>+task+=+new+Callable<Object>()+{
++++++++++++public+Object+call()+throws+InterruptedException+{
++++++++++++++++Thread.sleep(1100);
++++++++++++++++return+new+NewTimeout().simpleMethod();
++++++++++++}
++++++++};
++++++++Future<Object>+future+=+executor.submit(task);
++++++++try+{
++++++++++++Object+result+=+future.get(1,+TimeUnit.SECONDS);+
++++++++++++System.out.println(result);
++++++++}+catch+(TimeoutException+ex)+{
++++++++++++System.out.println("Timeout............Timeout...........");
++++++++}+catch+(InterruptedException+e)+{
++++++++++++//+handle+the+interrupts
++++++++}+catch+(ExecutionException+e)+{
++++++++++++//+handle+other+exceptions
++++++++}+finally+{
++++++++++++executor.shutdown();+//+may+or+may+not+desire+this
++++++++}
++++}
}|code-block|syntax|javascript|1498364|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I'm giving you here the complete code. In place of the method I'm calling, you can use your method:

<pre><code>public class NewTimeout {
 public String simpleMethod() {
 return "simple method";
 }

 public static void main(String[] args) {
 ExecutorService executor = Executors.newSingleThreadScheduledExecutor();
 Callable&lt;Object&gt; task = new Callable&lt;Object&gt;() {
 public Object call() throws InterruptedException {
 Thread.sleep(1100);
 return new NewTimeout().simpleMethod();
 }
 };
 Future&lt;Object&gt; future = executor.submit(task);
 try {
 Object result = future.get(1, TimeUnit.SECONDS); 
 System.out.println(result);
 } catch (TimeoutException ex) {
 System.out.println("Timeout............Timeout...........");
 } catch (InterruptedException e) {
 // handle the interrupts
 } catch (ExecutionException e) {
 // handle other exceptions
 } finally {
 executor.shutdown(); // may or may not desire this
 }
 }
}
</code></pre>

blocks|key|1283278|text|Thread+thread+=+new+Thread(new+Runnable()+{
++++public+void+run()+{
++++++++something.blockingMethod();
++++}
});
thread.start();
thread.join(2000);
if+(thread.isAlive())+{
++++thread.stop();
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1283279|注意，stop已被弃用，更好的替代方法是设置一些易失性布尔标志，在blockingMethod()中检查并退出，如下所示：|unstyled|1283280|import+org.junit.*;
import+java.util.*;
import+junit.framework.TestCase;

public+class+ThreadTest+extends+TestCase+{
++++static+class+Something+implements+Runnable+{
++++++++private+volatile+boolean+stopRequested;
++++++++private+final+int+steps;
++++++++private+final+long+waitPerStep;

++++++++public+Something(int+steps,+long+waitPerStep)+{
++++++++++++this.steps+=+steps;
++++++++++++this.waitPerStep+=+waitPerStep;
++++++++}

++++++++@Override
++++++++public+void+run()+{
++++++++++++blockingMethod();
++++++++}

++++++++public+void+blockingMethod()+{
++++++++++++try+{
++++++++++++++++for+(int+i+=+0;+i+<+steps+&&+!stopRequested;+i%2B%2B)+{
++++++++++++++++++++doALittleBit();
++++++++++++++++}
++++++++++++}+catch+(InterruptedException+e)+{
++++++++++++++++throw+new+RuntimeException(e);
++++++++++++}
++++++++}

++++++++public+void+doALittleBit()+throws+InterruptedException+{
++++++++++++Thread.sleep(waitPerStep);
++++++++}

++++++++public+void+setStopRequested(boolean+stopRequested)+{
++++++++++++this.stopRequested+=+stopRequested;
++++++++}
++++}

++++@Test
++++public+void+test()+throws+InterruptedException+{
++++++++final+Something+somethingRunnable+=+new+Something(5,+1000);
++++++++Thread+thread+=+new+Thread(somethingRunnable);
++++++++thread.start();
++++++++thread.join(2000);
++++++++if+(thread.isAlive())+{
++++++++++++somethingRunnable.setStopRequested(true);
++++++++++++thread.join(2000);
++++++++++++assertFalse(thread.isAlive());
++++++++}+else+{
++++++++++++fail("Exptected+to+be+alive+(5+*+1000+>+2000)");
++++++++}
++++}
}|1283281|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>Thread thread = new Thread(new Runnable() {
 public void run() {
 something.blockingMethod();
 }
});
thread.start();
thread.join(2000);
if (thread.isAlive()) {
 thread.stop();
}
</code></pre>

Note, that stop is deprecated, better alternative is to set some volatile boolean flag, inside blockingMethod() check it and exit, like this:

<pre><code>import org.junit.*;
import java.util.*;
import junit.framework.TestCase;

public class ThreadTest extends TestCase {
 static class Something implements Runnable {
 private volatile boolean stopRequested;
 private final int steps;
 private final long waitPerStep;

 public Something(int steps, long waitPerStep) {
 this.steps = steps;
 this.waitPerStep = waitPerStep;
 }

 @Override
 public void run() {
 blockingMethod();
 }

 public void blockingMethod() {
 try {
 for (int i = 0; i &lt; steps &amp;&amp; !stopRequested; i++) {
 doALittleBit();
 }
 } catch (InterruptedException e) {
 throw new RuntimeException(e);
 }
 }

 public void doALittleBit() throws InterruptedException {
 Thread.sleep(waitPerStep);
 }

 public void setStopRequested(boolean stopRequested) {
 this.stopRequested = stopRequested;
 }
 }

 @Test
 public void test() throws InterruptedException {
 final Something somethingRunnable = new Something(5, 1000);
 Thread thread = new Thread(somethingRunnable);
 thread.start();
 thread.join(2000);
 if (thread.isAlive()) {
 somethingRunnable.setStopRequested(true);
 thread.join(2000);
 assertFalse(thread.isAlive());
 } else {
 fail("Exptected to be alive (5 * 1000 &gt; 2000)");
 }
 }
}
</code></pre>

blocks|key|1283498|text|尝尝这个。更简单的解决方案。保证if块没有在时间限制内执行。进程将终止并抛出异常。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1283499|public+class+TimeoutBlock+{

+private+final+long+timeoutMilliSeconds;
++++private+long+timeoutInteval=100;

++++public+TimeoutBlock(long+timeoutMilliSeconds){
++++++++this.timeoutMilliSeconds=timeoutMilliSeconds;
++++}

++++public+void+addBlock(Runnable+runnable)+throws+Throwable{
++++++++long+collectIntervals=0;
++++++++Thread+timeoutWorker=new+Thread(runnable);
++++++++timeoutWorker.start();
++++++++do{+
++++++++++++if(collectIntervals>=this.timeoutMilliSeconds){
++++++++++++++++timeoutWorker.stop();
++++++++++++++++throw+new+Exception("<<<<<<<<<<****>>>>>>>>>>>+Timeout+Block+Execution+Time+Exceeded+In+"%2BtimeoutMilliSeconds%2B"+Milli+Seconds.+Thread+Block+Terminated.");
++++++++++++}
++++++++++++collectIntervals%2B=timeoutInteval;+++++++++++
++++++++++++Thread.sleep(timeoutInteval);

++++++++}while(timeoutWorker.isAlive());
++++++++System.out.println("<<<<<<<<<<####>>>>>>>>>>>+Timeout+Block+Executed+Within+"%2BcollectIntervals%2B"+Milli+Seconds.");
++++}

++++/**
+++++*+@return+the+timeoutInteval
+++++*/
++++public+long+getTimeoutInteval()+{
++++++++return+timeoutInteval;
++++}

++++/**
+++++*+@param+timeoutInteval+the+timeoutInteval+to+set
+++++*/
++++public+void+setTimeoutInteval(long+timeoutInteval)+{
++++++++this.timeoutInteval+=+timeoutInteval;
++++}
}|code-block|syntax|javascript|1283500|示例：|1283501|try+{
++++++++TimeoutBlock+timeoutBlock+=+new+TimeoutBlock(10+*+60+*+1000);//set+timeout+in+milliseconds
++++++++Runnable+block=new+Runnable()+{

++++++++++++@Override
++++++++++++public+void+run()+{
++++++++++++++++//TO+DO+write+block+of+code+
++++++++++++}
++++++++};

++++++++timeoutBlock.addBlock(block);//+execute+the+runnable+block+

++++}+catch+(Throwable+e)+{
++++++++//catch+the+exception+here+.+Which+is+block+didn't+execute+within+the+time+limit
++++}|1283502|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Try this. More simple solution. Guarantees that if block didn't execute within the time limit. the process will terminate and throws an exception.

<pre><code>public class TimeoutBlock {

 private final long timeoutMilliSeconds;
 private long timeoutInteval=100;

 public TimeoutBlock(long timeoutMilliSeconds){
 this.timeoutMilliSeconds=timeoutMilliSeconds;
 }

 public void addBlock(Runnable runnable) throws Throwable{
 long collectIntervals=0;
 Thread timeoutWorker=new Thread(runnable);
 timeoutWorker.start();
 do{ 
 if(collectIntervals&gt;=this.timeoutMilliSeconds){
 timeoutWorker.stop();
 throw new Exception("&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;****&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt; Timeout Block Execution Time Exceeded In "+timeoutMilliSeconds+" Milli Seconds. Thread Block Terminated.");
 }
 collectIntervals+=timeoutInteval; 
 Thread.sleep(timeoutInteval);

 }while(timeoutWorker.isAlive());
 System.out.println("&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;####&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt; Timeout Block Executed Within "+collectIntervals+" Milli Seconds.");
 }

 /**
 * @return the timeoutInteval
 */
 public long getTimeoutInteval() {
 return timeoutInteval;
 }

 /**
 * @param timeoutInteval the timeoutInteval to set
 */
 public void setTimeoutInteval(long timeoutInteval) {
 this.timeoutInteval = timeoutInteval;
 }
}
</code></pre>

example :

<pre><code>try {
 TimeoutBlock timeoutBlock = new TimeoutBlock(10 * 60 * 1000);//set timeout in milliseconds
 Runnable block=new Runnable() {

 @Override
 public void run() {
 //TO DO write block of code 
 }
 };

 timeoutBlock.addBlock(block);// execute the runnable block 

 } catch (Throwable e) {
 //catch the exception here . Which is block didn't execute within the time limit
 }
</code></pre>

blocks|key|1498160|text|假设blockingMethod只是睡了几个小时：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1498161|public+void+blockingMethod(Object+input)+{
++++try+{
++++++++Thread.sleep(3000);
++++}+catch+(InterruptedException+e)+{
++++++++e.printStackTrace();
++++}
}|code-block|syntax|javascript|1498162|我的解决方案是像这样使用wait()和synchronized：|1498163|public+void+blockingMethod(final+Object+input,+long+millis)+{
++++final+Object+lock+=+new+Object();
++++new+Thread(new+Runnable()+{

++++++++@Override
++++++++public+void+run()+{
++++++++++++blockingMethod(input);
++++++++++++synchronized+(lock)+{
++++++++++++++++lock.notify();
++++++++++++}
++++++++}
++++}).start();
++++synchronized+(lock)+{
++++++++try+{
++++++++++++//+Wait+for+specific+millis+and+release+the+lock.
++++++++++++//+If+blockingMethod+is+done+during+waiting+time,+it+will+wake
++++++++++++//+me+up+and+give+me+the+lock,+and+I+will+finish+directly.
++++++++++++//+Otherwise,+when+the+waiting+time+is+over+and+the
++++++++++++//+blockingMethod+is+still
++++++++++++//+running,+I+will+reacquire+the+lock+and+finish.
++++++++++++lock.wait(millis);
++++++++}+catch+(InterruptedException+e)+{
++++++++++++e.printStackTrace();
++++++++}
++++}
}|1498164|所以你可以替换|1498165|something.blockingMethod(input)|1498166|至|1498167|something.blockingMethod(input,+2000)|1498168|希望能有所帮助。|1498169|entityMap^0|2|E|0|0|C|6|J|C|0|0|0|0|V|0|0|0|11|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1A|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|S|3|T|5|6|7|1E|8|@]|D|@]|E|$]]|$1|U|3|V|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|W|3|X|5|6|7|1I|8|@]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|Z|$]]

Assume <code>blockingMethod</code> just sleep for some millis:

<pre><code>public void blockingMethod(Object input) {
 try {
 Thread.sleep(3000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
}
</code></pre>

My solution is to use <code>wait()</code> and <code>synchronized</code> like this:

<pre><code>public void blockingMethod(final Object input, long millis) {
 final Object lock = new Object();
 new Thread(new Runnable() {

 @Override
 public void run() {
 blockingMethod(input);
 synchronized (lock) {
 lock.notify();
 }
 }
 }).start();
 synchronized (lock) {
 try {
 // Wait for specific millis and release the lock.
 // If blockingMethod is done during waiting time, it will wake
 // me up and give me the lock, and I will finish directly.
 // Otherwise, when the waiting time is over and the
 // blockingMethod is still
 // running, I will reacquire the lock and finish.
 lock.wait(millis);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
}
</code></pre>

So u can replace

<code>something.blockingMethod(input)</code> 

to 

<code>something.blockingMethod(input, 2000)</code>

Hope it helps.

blocks|key|1283475|text|您需要一个类似于GitHub上的failsafe项目中的circuit+breaker实现。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1283476|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/jhalterman/failsafe|1|http://martinfowler.com/bliki/CircuitBreaker.html^0|G|8|0|S|F|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

You need a <a href="http://martinfowler.com/bliki/CircuitBreaker.html" rel="nofollow">circuit breaker</a> implementation like the one present in the <a href="https://github.com/jhalterman/failsafe" rel="nofollow">failsafe</a> project on GitHub.

blocks|key|1498533|text|在阻塞队列的特殊情况下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1498534|泛型java.util.concurrent.SynchronousQueue有一个带有超时参数的poll方法。|offset|length|style|CODE|1498535|entityMap^0|0|2|11|1D|4|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|I|$]]

In special case of a blocking queue:
Generic <code>java.util.concurrent.SynchronousQueue</code> has a <code>poll</code> method with timeout parameter.

Is there a standard nice way to call a blocking method with a timeout in Java? I want to be able to do:

<pre><code>// call something.blockingMethod();
// if it hasn't come back within 2 seconds, forget it
</code></pre>

if that makes sense.

Thanks.

How do I call some blocking method with a timeout in Java?

在Java中有没有一种标准的很好的方法来调用带有超时的阻塞方法？我希望能够做到：// call something.blockingMethod();// if it hasn't come back within 2 seconds, forget it如果这有意义的话。谢谢。

问如何在Java中调用带有超时的阻塞方法？
EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Java中调用带有超时的阻塞方法？EN

回答 10

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在Java中调用带有超时的阻塞方法？
EN