blocks|key|1167185|text|interrupted()为static并检查当前线程。isInterrupted()是一个实例方法，它检查调用它的Thread对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1167186|常见的错误是在实例上调用静态方法。|1167187|Thread+myThread+=+...;
if+(myThread.interrupted())+{}+//+WRONG!+This+might+not+be+checking+myThread.
if+(myThread.isInterrupted())+{}+//+Right!|code-block|syntax|javascript|1167188|另一个不同之处在于，interrupted()还会清除当前线程的状态。换句话说，如果您连续调用它两次，并且线程在两次调用之间没有中断，那么即使第一次调用返回true，第二次调用也会返回false。|1167189|Javadocs告诉你像这样重要的事情；经常使用它们！|1167190|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/javase/6/docs/api/java/lang/Thread.html#interrupted()|1|http://java.sun.com/javase/6/docs/api/java/lang/Thread.html#isInterrupted()|2|http://java.sun.com/javase/6/docs/api/index.html^0|0|D|E|6|S|F|1M|6|0|D|0|S|F|1|0|0|0|A|D|26|4|2K|5|0|0|8|2|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@$9|1B|A|1C|1|1D]|$9|1E|A|1F|1|1G]]|E|$]]|$1|F|3|G|5|6|7|1H|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1I|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1J|8|@$9|1K|A|1L|B|C]|$9|1M|A|1N|B|C]|$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1Q|8|@]|D|@$9|1R|A|1S|1|1T]]|E|$]]|$1|Q|3|-4|5|6|7|1U|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]|Y|$5|T|U|V|E|$W|Z]]|10|$5|T|U|V|E|$W|11]]]]

<a href="http://java.sun.com/javase/6/docs/api/java/lang/Thread.html#interrupted()" rel="noreferrer"><code>interrupted()</code></a> is <code>static</code> and checks the current thread. <a href="http://java.sun.com/javase/6/docs/api/java/lang/Thread.html#isInterrupted()" rel="noreferrer"><code>isInterrupted()</code></a> is an instance method which checks the <code>Thread</code> object that it is called on.

A common error is to call a static method on an instance.

<pre><code>Thread myThread = ...;
if (myThread.interrupted()) {} // WRONG! This might not be checking myThread.
if (myThread.isInterrupted()) {} // Right!
</code></pre>

Another difference is that <code>interrupted()</code> also clears the status of the current thread. In other words, if you call it twice in a row and the thread is not interrupted between the two calls, the second call will return <code>false</code> even if the first call returned <code>true</code>.

The <a href="http://java.sun.com/javase/6/docs/api/index.html" rel="noreferrer">Javadocs</a> tell you important things like this; use them often!

blocks|key|1382139|text|如果你使用interrupted，你会问：“自从我上次问起，我是否被打断了？”|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1382140|isInterrupted会告诉您调用它的线程当前是否被中断。|1382141|entityMap^0|5|B|0|0|D|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

If you use <code>interrupted</code>, what you're asking is "Have I been interrupted since the last time I asked?"

<code>isInterrupted</code> tells you whether the thread you call it on is currently interrupted.

blocks|key|1167340|text|Java中的线程中断是建议性的。如果您调用Thread.interrupt()，那么它将设置标志并取消所有未完成的IO任务(这将抛出InterruptedException)。然而，这是由在线程中执行的代码来处理的。这样做称为实现线程中断策略。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1167341|然而，因为线程的中断状态是共享的，所以任何这样的处理都是线程安全的，这一点很重要。如果您正在处理中断标志，您不会希望其他线程停止并尝试执行某些操作。由于这个原因，Thread.interrupted()标志使它成为原子的，所以当你想说：“如果这个线程被中断了，我就去处理它”时使用它。通常这将涉及清理一些资源。一旦你完成了，你可能应该传播中断标志，以便调用者可以处理它。你可以通过再次调用Thread.interrupt来做到这一点。|1167342|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Thread interruption in Java is advisory. If you call Thread.interrupt() then it will set the flag and cancel any outstanding IO tasks (which will throw InterruptedException). However it is up to code that is executing in the thread to handle this. Doing so is called implementing the Thread interruption policy.
However because Thread's interrupted state is shared it is important that any such handling be Thread Safe. You don't want some other thread going off and trying to do something with the interrupted flag if you are handling it. For this reason the Thread.interrupted() flag makes this atomic so it is used when you want to say: &quot;If this thread was interrupted then I am going to deal with it). Usually this will involve cleaning up some resources. Once you are done you should probably propogate the interrupted flag so that callers can handle it. You can do this by calling Thread.interrupt again.

blocks|key|1382298|text|interrupted()方法是一个静态的类方法，线程检查当前线程并清除中断的“标志”.i.e。第二次调用interrupted()将返回false。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1382299|isInterrupted()方法是一个实例方法；它报告调用它的线程的状态。它不会清除中断标志。|1382300|如果设置了该标志，则在调用此方法后它将保持设置状态。|1382301|Thread+myThread+=+...;
if+(myThread.interrupted())+{}+//error

Thread.interrupted()//right

if+(myThread.isInterrupted())+{}+//+Right|code-block|syntax|javascript|1382302|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|P|8|@]|9|@]|A|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

interrupted() method is a static method of class thread checks the current thread and clear the interruption "flag".i.e. a second call to interrupted() will return false.

isInterrupted() method is an instance method; it reports the status of the thread on which it is invoked. it does not clear the interruption flag. 

If the flag is set, it will remain set after calling this method.

<pre><code>Thread myThread = ...;
if (myThread.interrupted()) {} //error

Thread.interrupted()//right

if (myThread.isInterrupted()) {} // Right
</code></pre>

blocks|key|1382417|text|这是一个古老的问题，在浏览了答案之后，我觉得仍然有一些缺失的信息。这是我试图填补这一缺失的信息。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1382418|从Java5开始，通常只能间接处理线程，从java.util.Executor框架派生的.Infact线程是在库方法中处理的。这些线程通常调用具有阻塞性质的实体，如Future.get()。ie+get()阻塞，直到结果可用.Now有一种重载形式的get()，它接受超时值，调用该方法意味着线程希望等待一段等于超时的时间，以便get+()返回值，如果不是，则可以通过Future.cancel()取消该任务。因此，这些方法会认真处理中断，因为一旦嗅探到中断，它们也会抛出检查过的InterruptionException。因此，调用者被迫处理InterruptionException。由于它们已经传播了传达中断状态的InterruptedException，因此阻塞方法也可以通过调用Thread.interrupt()来清除中断状态。否则，将违反InterruptedException的合同。|offset|length|style|CODE|1382419|但是，如果您正在处理的是原始线程，那么在调用静态方法interrupted()时应该小心，因为如果您连续调用该方法两次，并且线程在两次调用之间没有中断，那么即使第一次调用返回true，第二次调用也会返回false。|1382420|entityMap|0|LINK|mutability|MUTABLE|url|http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/concurrent/Future.java#Future.cancel%2528boolean%2529^0|0|2A|C|2Q|5|3G|5|4J|6|53|F|0|0|Q|D|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@$D|T|E|U|F|G]|$D|V|E|W|F|G]|$D|X|E|Y|F|G]|$D|Z|E|10|F|G]]|9|@$D|11|E|12|1|13]]|A|$]]|$1|H|3|I|5|6|7|14|8|@$D|15|E|16|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]]]

This is a old question and having gone through the answers I feel that there is still some missing information. Here's my attempt to fill in that missing piece of info.

From Java 5 onwards usually you would deal with Threads only indirectly .Infact threads spawned from the java.util.Executor framework are dealt within library methods. These threads often call entities that are of blocking nature like <code>Future.get()</code> . ie <code>get()</code> blocks untill result is available .Now there is a overloaded form of <code>get()</code> that takes a timeout value and calling that method means that the thread wants to wait for a period equal to the timeout for the <code>get ()</code> to return a value ,if not that task can be cancelled via <a href="http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/concurrent/Future.java#Future.cancel%28boolean%29" rel="nofollow">Future.cancel()</a>. So these methods deal with interruption seriously in that as soon as they sniff a interruption , they also throw the checked InterruptionException . Hence the callers are forced to handle InterruptionException. Since they already propagate the InterruptedException which conveys the interrupted status , it makes sense for the blocking mehthods to also clear the interrupted status by calling Thread.interrupt(). Otherwise , the contract of InterruptedException is violated.

However , if you are dealing with raw threads which is ofcourse not recommnended now , you should be careful when calling the static method <code>interrupted()</code> because if you call it twice in a row and the thread is not interrupted between the two calls, the second call will return false even if the first call returned true.

Java question: As far as I know, there are two ways to check inside a thread whether the thread received an interrupt signal, <code>Thread.interrupted()</code> and <code>Thread.isInterrupted()</code>, and the only difference between them is that the former resets the internal interrupted flag.

So far, I've always used <code>Thread.isInterrupted()</code> and never had any problems with it. Then again, most tutorials I've seen recommend using <code>Thread.interrupted()</code>. Is there any specific reason for that?

Java: Difference in usage between Thread.interrupted() and Thread.isInterrupted()?

Java

据我所知，在线程内部检查线程是否收到中断信号有两种方法，Thread.interrupted()和Thread.isInterrupted()，它们之间唯一的区别是前者重置了内部中断标志。到目前为止，我一直在使用Thread.isInterrupted()，从来没有遇到过任何问题。话又说回来，我看过的大多数教程都推荐使...

问Thread.interrupted()和Thread.isInterrupted()的用法有什么不同？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Thread.interrupted()和Thread.isInterrupted()的用法有什么不同？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Thread.interrupted()和Thread.isInterrupted()的用法有什么不同？
EN