blocks|key|3268331|text|如果你在线程的顶层--或者能够干净利落地到达顶层--那么直接返回是很好的。抛出异常并不是很干净，因为您需要能够检查没有任何东西会捕获异常并忽略它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3268332|您需要使用Thread.currentThread()来调用interrupt()的原因是，interrupt()是一个实例方法-您需要在您想要中断的线程上调用它，在本例中，该线程恰好是当前线程。请注意，中断只会在线程下一次阻塞(例如，对于IO或监视器)时才会被注意到-这并不意味着立即抛出异常。|offset|length|style|CODE|3268333|entityMap^0|0|5|M|U|B|1A|B|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]|$D|P|E|Q|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|I|$]]

If you're at the top level - or able to cleanly get to the top level - of the thread, then just returning is nice. Throwing an exception isn't as clean, as you need to be able to check that nothing's going to catch the exception and ignore it.

The reason you need to use <code>Thread.currentThread()</code> in order to call <code>interrupt()</code> is that <code>interrupt()</code> is an instance method - you need to call it on the thread you want to interrupt, which in your case happens to be the current thread. Note that the interruption will only be noticed the next time the thread would block (e.g. for IO or for a monitor) anyway - it doesn't mean the exception is thrown immediately.

blocks|key|3268367|text|thread是一个类，而不是一个实例；Thread+()是一个静态方法，它返回与调用线程相对应的currentThread实例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3268368|使用(2)。对于正常使用来说，interrupt()有点残酷。|3268369|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 is a class, not an instance; currentThread() is a static method that returns the Thread instance corresponding to the calling thread.

Use (2). interrupt() is a bit brutal for normal use.

blocks|key|3268395|text|如果run方法结束，线程也将结束。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3268396|如果您使用循环，正确的方式如下所示：|3268397|//+In+your+imlemented+Runnable+class:
private+volatile+boolean+running+=+true;

public+void+run()
{
+++while+(running)
+++{
++++++...
+++}
}


public+void+stopRunning()
{
++++running+=+false;
}|code-block|syntax|javascript|3268398|当然，返回是最好的方式。|3268399|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|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If the run method ends, the thread will end.

If you use a loop, a proper way is like following:

<pre><code>// In your imlemented Runnable class:
private volatile boolean running = true;

public void run()
{
 while (running)
 {
 ...
 }
}


public void stopRunning()
{
 running = false;
}
</code></pre>

Of course returning is the best way.

blocks|key|315822|text|如果你想终止线程，那么只需返回即可。您不需要调用Thread.currentThread().interrupt()+(尽管它不会做任何坏事。只是你不需要这样做。)这是因为interrupt()基本上是用来通知线程的所有者的(嗯，不是100%25准确，但在某种程度上)。因为您是线程的所有者，并且您决定终止线程，所以没有人需要通知，所以您不需要调用它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|315823|顺便问一下，为什么在第一种情况下我们需要使用currentThread？线程是否未引用当前线程？|315824|315825|我猜它可能会让人感到困惑，比如Thread.sleep()会影响当前线程，但Thread.sleep()是一个静态方法。|315826|如果您不是线程的所有者(例如，如果您没有扩展Thread并编写Runnable等)你应该这样做|315827|Thread.currentThread().interrupt();
return;|code-block|syntax|javascript|315828|这样，任何调用你的runnable的代码都会知道线程被中断了=(通常)应该停止它正在做的事情并终止它。正如我之前所说的，它只是一种沟通机制。所有者可能会简单地忽略中断状态，什么也不做。但是，如果您设置了中断状态，将来可能会有人为此感谢您。|315829|出于同样的原因，您永远不应该这样做|315830|Catch(InterruptedException+ie){
+++++//ignore
}|315831|因为如果你这样做了，你就停止了这条消息。相反，人们应该做的是|315832|Catch(InterruptedException+ie){
++++Thread.currentThread().interrupt();//preserve+the+message
++++return;//Stop+doing+whatever+I+am+doing+and+terminate
}|315833|entityMap^0|O|Y|2E|B|0|0|0|0|M|6|V|8|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|18|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|19|8|@]|D|@]|E|$]]|$1|I|3|J|5|6|7|1A|8|@]|D|@]|E|$]]|$1|K|3|L|5|6|7|1B|8|@$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|M|3|N|5|O|7|1G|8|@]|D|@]|E|$P|Q]]|$1|R|3|S|5|6|7|1H|8|@]|D|@]|E|$]]|$1|T|3|U|5|6|7|1I|8|@]|D|@]|E|$]]|$1|V|3|W|5|O|7|1J|8|@]|D|@]|E|$P|Q]]|$1|X|3|Y|5|6|7|1K|8|@]|D|@]|E|$]]|$1|Z|3|10|5|O|7|1L|8|@]|D|@]|E|$P|Q]]|$1|11|3|-4|5|6|7|1M|8|@]|D|@]|E|$]]]|12|$]]

If you want to terminate the thread, then just returning is fine. You do NOT need to call <code>Thread.currentThread().interrupt()</code> (it will not do anything bad though. It's just that you don't need to.) This is because <code>interrupt()</code> is basically used to notify the owner of the thread (well, not 100% accurate, but sort of). Because you are the owner of the thread, and you decided to terminate the thread, there is no one to notify, so you don't need to call it. 

<blockquote>
 By the way, why in the first case we
 need to use currentThread? Is Thread
 does not refer to the current thread?
</blockquote>

Yes, it doesn't. I guess it can be confusing because e.g. Thread.sleep() affects the current thread, but Thread.sleep() is a static method.

If you are NOT the owner of the thread (e.g. if you have not extended <code>Thread</code> and coded a <code>Runnable</code> etc.) you should do

<pre><code>Thread.currentThread().interrupt();
return;
</code></pre>

This way, whatever code that called your runnable will know the thread is interrupted = (normally) should stop whatever it is doing and terminate. As I said earlier, it is just a mechanism of communication though. The owner might simply ignore the interrupted status and do nothing.. but if you do set the interrupted status, somebody might thank you for that in the future. 

For the same reason, you should never do 

<pre><code>Catch(InterruptedException ie){
 //ignore
}
</code></pre>

Because if you do, you are stopping the message there. Instead one should do 

<pre><code>Catch(InterruptedException ie){
 Thread.currentThread().interrupt();//preserve the message
 return;//Stop doing whatever I am doing and terminate
}
</code></pre>

blocks|key|315835|text|如果只调用interrupt()，线程将不会自动关闭。相反，如果相应地实现isInterrupted()，线程甚至可能继续存在。按照OP的要求，保证关闭线程的唯一方法是|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|315836|Thread.currentThread().stop();|code-block|syntax|javascript|315837|但是，方法已被弃用。|315838|调用return仅从当前方法返回。只有当你在线程的顶层时，这才会终止线程。|315839|不过，您应该使用interrupt()并围绕它构建代码。|315840|entityMap^0|5|B|11|F|0|0|0|2|6|0|8|B|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|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|R|$]]

If you simply call <code>interrupt()</code>, the thread will not automatically be closed. Instead, the Thread might even continue living, if <code>isInterrupted()</code> is implemented accordingly. The only way to guaranteedly close a thread, as asked for by OP, is

<pre><code>Thread.currentThread().stop();
</code></pre>

Method is deprecated, however.

Calling <code>return</code> only returns from the current method. This only terminates the thread if you're at its top level.

Nevertheless, you should work with <code>interrupt()</code> and build your code around it.

This is a short question. At some point my thread understand that it should suicide. What is the best way to do it:

<ol>
<li>Thread.currentThread().interrupt();</li>
<li>return;</li>
</ol>

By the way, why in the first case we need to use <code>currentThread</code>? Is <code>Thread</code> does not refer to the current thread?

How a thread should close itself in Java?

这是一个简短的问题。在某种程度上，我的线程明白它应该自杀。最好的方法是什么：Thread.currentThread().interrupt();return;顺便问一下，为什么在第一种情况下我们需要使用currentThread？Thread不引用当前线程吗？

问在Java中，线程应该如何关闭自身？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中，线程应该如何关闭自身？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中，线程应该如何关闭自身？
EN