blocks|key|1680081|text|区别是非常微妙的，通常并不重要。显然，您可以根据自己的意愿设置或清除中断标志。甚至没有一个标准的实践说“使用一个，而不是使用另一个”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1680082|主要的一点是要知道你对中断标志做了什么:让它处于一种你不是特别想要的状态，这肯定不会只是一个细微的差别。|1680083|切勿使用Thread.currentThread().interrupted()。这只会产生误导，特别是如果你有someOtherThread.interrupted()的话。|offset|length|style|CODE|1680084|entityMap^0|0|0|4|10|1K|T|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@$F|O|G|P|H|I]|$F|Q|G|R|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|K|$]]

The difference is very subtle and usually doesn't matter. You can obviously set or clear the interrupted flag as you wish. There isn't even a standard practice that says "use one and never use the other". 

The main point is to know what you are doing with the interrupted flag: leaving it in a state which you didn't specifically intend would definitely not make just a subtle difference.

Never use <code>Thread.currentThread().interrupted()</code>. This would just be misleading, especially if you had <code>someOtherThread.interrupted()</code>.

blocks|key|523526|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|523527|与使用Thread.interrupted()有什么不同(除了在使用interrupted()时会清除中断标志)？|blockquote|offset|length|style|CODE|523528|523529|523530|不，但这是一个相当深刻的区别。如果您只是像在示例中那样使用它，在线程的run方法中的单个while循环中使用它，以便run方法在线程中断时退出，那么没有区别，但在其他情况下可能会有区别。例如，想象一下嵌套循环，每个循环检查中断状态(内部循环在外部循环检查之前清除状态...)|523531|至于Thread.currentThread().interrupted()和Thread.interrupted()之间的区别，在功能上没有区别，但后者更短，所以请使用它。|523532|entityMap^0|0|3|K|Y|D|0|0|0|Z|3|18|5|1M|3|0|2|10|13|K|0^^$0|@$1|2|3|-4|4|5|6|P|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|Q|7|@$D|R|E|S|F|G]|$D|T|E|U|F|G]]|8|@]|9|$]]|$1|H|3|-4|4|5|6|V|7|@]|8|@]|9|$]]|$1|I|3|-4|4|5|6|W|7|@]|8|@]|9|$]]|$1|J|3|K|4|5|6|X|7|@$D|Y|E|Z|F|G]|$D|10|E|11|F|G]|$D|12|E|13|F|G]]|8|@]|9|$]]|$1|L|3|M|4|5|6|14|7|@$D|15|E|16|F|G]|$D|17|E|18|F|G]]|8|@]|9|$]]|$1|N|3|-4|4|5|6|19|7|@]|8|@]|9|$]]]|O|$]]

<blockquote>
 is there any difference to using <code>Thread.interrupted()</code> (other than that the interrupted flag being cleared when using <code>interrupted()</code>)?
</blockquote>

No, but that's quite a profound difference. If you're only using it as in your example, inside a single <code>while</code> loop in the thread's <code>run</code> method, so that the <code>run</code> method exits when the thread interrupted, then there's no difference, but in other scenarios there could be. For example, imagine nested loops, each checking for the interrupted status (and the inner ones clearing the status before the outer ones get to check for it...)

As for difference between <code>Thread.currentThread().interrupted()</code> vs. <code>Thread.interrupted()</code>, there's no functional difference, but the latter is shorter so use it.

blocks|key|3804034|text|回答你问题的最后一部分..。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3804035|3804036|我也见过Thread.currentThread().interrupted()。这是正确的使用方式，还是Thread.interrupted()就足够了？|blockquote|offset|length|style|CODE|3804037|3804038|3804039|在纯功能术语中，它们的含义完全相同。|3804040|但是在可读性方面，|3804041|++++Thread.currentThread().interrupted()|code-block|syntax|javascript|3804042|让它看起来像是在调用一个实例方法...但你不是。因此，|3804043|++++Thread.interrupted()|3804044|是更好的。当然也不要这样做：|3804045|++++Thread+someThread+=+...
++++someThread.interrupted()|3804046|看起来您是在测试someThread，但实际上您是在测试当前线程。非常具有误导性！|3804047|entityMap^0|0|0|4|10|1H|K|0|0|0|0|0|0|0|0|0|0|8|A|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|18|8|@$F|19|G|1A|H|I]|$F|1B|G|1C|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1F|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1G|8|@]|9|@]|A|$]]|$1|P|3|Q|5|R|7|1H|8|@]|9|@]|A|$S|T]]|$1|U|3|V|5|6|7|1I|8|@]|9|@]|A|$]]|$1|W|3|X|5|R|7|1J|8|@]|9|@]|A|$S|T]]|$1|Y|3|Z|5|6|7|1K|8|@]|9|@]|A|$]]|$1|10|3|11|5|R|7|1L|8|@]|9|@]|A|$S|T]]|$1|12|3|13|5|6|7|1M|8|@$F|1N|G|1O|H|I]]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1P|8|@]|9|@]|A|$]]]|15|$]]

Just answering the last part of your question ...

<blockquote>
 I have also seen <code>Thread.currentThread().interrupted()</code>. Is that the correct way to use it, or is <code>Thread.interrupted()</code> sufficient?
</blockquote>

In purely functional terms, they mean exactly the same thing.

But in terms of readability,

<pre><code> Thread.currentThread().interrupted()
</code></pre>

makes it look like you are calling an instance method ... but you are not. Therefore,

<pre><code> Thread.interrupted()
</code></pre>

is better. And certainly DO NOT do this:

<pre><code> Thread someThread = ...
 someThread.interrupted()
</code></pre>

It looks like you would be testing <code>someThread</code>, but you are actually testing the current thread. Very misleading!

blocks|key|522545|text|正如您所说，不同之处在于清除线程的中断状态和不清除线程的中断状态。既然您已经知道了这一点，那么您真正要问的似乎是保留线程的中断状态是否重要。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|522546|首先，必须确定检查中断状态(或处理InterruptedException)的代码是否被视为线程的“所有者”。如果是这样，在某些有限的情况下，可以适当地接受(或不抛出)+InterruptedException以及中断状态，因为所有者正在实现线程的取消策略(Goetz，Java+Concurrency+in+Practice，p.143)。|offset|length|style|CODE|522547|但在绝大多数情况下，包括Runnable，有问题的代码不是线程所有者，并且不能吞噬取消状态。在这种情况下，您有两个选择：|BOLD|522548|522549|使线程中断状态保持清除状态，但抛出InterruptedException。(这就是Thread.sleep()+does.)|unordered-list-item|522550|Preserve+Thread.sleep()中断状态。|522551|522552|在Runnable的情况下，您不能引发检查异常，因为run()没有声明这样做。(反过来，我推测它是这样设计的，因为通常不会有人捕捉到它。)所以你唯一的选择就是保留取消状态。|522553|考虑到上面的解释，让我回到你直接的问题上。首先，如果你想查看取消状态并保存它，它更容易编写|522554|if+(Thread.currentThread().isInterrupted())+doSomething;|code-block|syntax|javascript|522555|比|522556|if+(Thread.interrupted())+{
++++Thread.currentThread().interrupt();
++++doSomething;
}|522557|此外，与您最初的问题一样，如果在while循环中使用Thread.interrupted()作为条件，那么在循环中断后，您将不知道它是否因为Thread.interrupted()返回true或其他条件更改或运行了break语句而终止。因此，在这种情况下，使用Thread.currentThread().isInterrupted()实际上是您唯一的选择。(当然，您也可以对循环进行编码，使其退出的唯一原因是线程被中断，但这样做会使代码变得脆弱，因为在循环之后，您必须重新中断线程，并且如果后来有人出于其他原因更改了代码，使其也中断了循环，那么您就会在线程最初没有中断的时候中断它。)|522558|对于你的第二个问题，正如其他人所说的那样，永远不要使用Thread.currentThread().interrupted()，因为它具有误导性。由于interrupted()是一种静态方法，如果您使用-Xlint编译，在这种情况下，编译器会给出一个有用的警告|522559|522560|警告:静态静态方法应由类型名和线程限定，而不是由表达式限定|blockquote|522561|522562|522563|其他一些工具可能会执行类似的操作，例如Eclipse，它将显示：|522564|线程类型的静态方法|522565|+()应以静态方式访问|522566|522567|entityMap^0|0|H|K|2D|K|0|C|8|11|2|0|0|H|K|16|E|0|9|E|0|0|1|8|Q|5|0|0|0|0|0|G|5|Q|K|1Y|K|2K|4|2Z|5|3M|12|0|R|10|23|D|2T|6|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1O|8|@$D|1P|E|1Q|F|G]|$D|1R|E|1S|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1T|8|@$D|1U|E|1V|F|G]|$D|1W|E|1X|F|J]]|9|@]|A|$]]|$1|K|3|-4|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1Z|8|@$D|20|E|21|F|G]|$D|22|E|23|F|G]]|9|@]|A|$]]|$1|O|3|P|5|N|7|24|8|@$D|25|E|26|F|G]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|27|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|28|8|@$D|29|E|2A|F|G]|$D|2B|E|2C|F|G]]|9|@]|A|$]]|$1|T|3|U|5|6|7|2D|8|@]|9|@]|A|$]]|$1|V|3|W|5|X|7|2E|8|@]|9|@]|A|$Y|Z]]|$1|10|3|11|5|6|7|2F|8|@]|9|@]|A|$]]|$1|12|3|13|5|X|7|2G|8|@]|9|@]|A|$Y|Z]]|$1|14|3|15|5|6|7|2H|8|@$D|2I|E|2J|F|G]|$D|2K|E|2L|F|G]|$D|2M|E|2N|F|G]|$D|2O|E|2P|F|G]|$D|2Q|E|2R|F|G]|$D|2S|E|2T|F|G]]|9|@]|A|$]]|$1|16|3|17|5|6|7|2U|8|@$D|2V|E|2W|F|G]|$D|2X|E|2Y|F|G]|$D|2Z|E|30|F|G]]|9|@]|A|$]]|$1|18|3|-4|5|6|7|31|8|@]|9|@]|A|$]]|$1|19|3|1A|5|1B|7|32|8|@]|9|@]|A|$]]|$1|1C|3|-4|5|6|7|33|8|@]|9|@]|A|$]]|$1|1D|3|-4|5|6|7|34|8|@]|9|@]|A|$]]|$1|1E|3|1F|5|6|7|35|8|@]|9|@]|A|$]]|$1|1G|3|1H|5|6|7|36|8|@]|9|@]|A|$]]|$1|1I|3|1J|5|1B|7|37|8|@]|9|@]|A|$]]|$1|1K|3|-4|5|6|7|38|8|@]|9|@]|A|$]]|$1|1L|3|-4|5|6|7|39|8|@]|9|@]|A|$]]]|1M|$]]

The difference, as you stated, is that one clears the thread's interrupt status and one does not. Since you already know that, it seems like what you're really asking is whether it's important to preserve the thread's interrupted status.

First one must determine whether the code checking the interrupt status (or handling an <code>InterruptedException</code>) is considered the "owner" of the thread. If so, in certain limited cases, it can be appropriate to swallow (or just not throw) an <code>InterruptedException</code> as well as the interrupted status because the owner is implementing the thread's cancellation policy (Goetz, Java Concurrency in Practice, p. 143).

But in the vast majority of cases, including a <code>Runnable</code>, the code in question is not the thread owner and must not swallow the cancellation status. In this case you have two options:

<ul>
<li>Leave the thread interrupt status cleared but throw an <code>InterruptedException</code>. (This is what <code>Thread.sleep()</code> does.)</li>
<li>Preserve the interrupt status.</li>
</ul>

In the case of a <code>Runnable</code>, you cannot throw a checked exception because <code>run()</code> is not declared to do so. (In turn, I theorize it was designed that way because there would usually not be anyone to catch it.) So your only choice is to preserve the cancellation status.

Given the above explanation, let me get back to your direct question. First of all, if you want to check the cancellation status and preserve it, it is easier to write

<pre><code>if (Thread.currentThread().isInterrupted()) doSomething;
</code></pre>

than

<pre><code>if (Thread.interrupted()) {
 Thread.currentThread().interrupt();
 doSomething;
}
</code></pre>

Furthermore, as in your original question, if you used <code>Thread.interrupted()</code> as the condition in a <code>while</code> loop, after the loop breaks you wouldn't know whether it terminated because <code>Thread.interrupted()</code> returned <code>true</code> or some other condition changed or a <code>break</code> statement ran. So in that case using <code>Thread.currentThread().isInterrupted()</code> is really your only option. (Of course you could also code the loop such that the only reason it would exit is that the thread is interrupted, but then your code would be fragile because after the loop you have to re-interrupt the thread and if someone else later came along and changed the code to also break out of the loop for some other reason, you'd then be interrupting the thread when it wasn't originally interrupted.)

To your second question, as others have stated, never use <code>Thread.currentThread().interrupted()</code> because it is misleading. Since <code>interrupted()</code> is a static method, in this case the compiler gives you a helpful warning if you compile with <code>-Xlint</code>:

<blockquote>
 warning: [static] static method should be qualified by type name, Thread, instead of by an expression
</blockquote>

Some other tools may do similarly, such as Eclipse, which will show:

<blockquote>
 The static method interrupted() from the type Thread should be accessed in a static way
</blockquote>

On stackoverflow, I often see the use of <code>Thread.currentThread().isInterrupted()</code>. When implementing <code>Runnable</code> and using it in a while loop, like so:

<pre><code>public void run() {
 while(!Thread.currentThread().isInterrupted()) { ... }
}
</code></pre>

is there any difference to using <code>Thread.interrupted()</code> (other than that the <code>interrupted</code> flag being cleared when using <code>interrupted()</code>)?

I have also seen <code>Thread.currentThread().interrupted()</code>. Is that the correct way to use it, or is <code>Thread.interrupted()</code> sufficient?

Why use Thread.currentThread().isInterrupted() instead of Thread.interrupted() when implementing Runnable?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在stackoverflow上，我经常看到Thread.currentThread().isInterrupted()的使用。在实现Runnable并在while循环中使用它时，如下所示：public void run() {  while(!Thread.currentThread().isInterrupted()...

问为什么在实现Runnable时使用Thread.currentThread().isInterrupted()而不是Thread.interrupted()？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在实现Runnable时使用Thread.currentThread().isInterrupted()而不是Thread.interrupted()？EN