/*** Forces the thread to stop executing.* <p>* If there is a security manager installed, its <code>checkAccess</code>* method is called with <code>this</code>* as its argument. This may result in a* <code>SecurityException</code> being raised (in the current thread).* <p>* If this thread is different from the current thread (that is, the current* thread is trying to stop a thread other than itself), the* security manager's <code>checkPermission</code> method (with a* <code>RuntimePermission("stopThread")</code> argument) is called in* addition.* Again, this may result in throwing a* <code>SecurityException</code> (in the current thread).* <p>* The thread represented by this thread is forced to stop whatever* it is doing abnormally and to throw a newly created* <code>ThreadDeath</code> object as an exception.* <p>* It is permitted to stop a thread that has not yet been started.* If the thread is eventually started, it immediately terminates.* <p>* An application should not normally try to catch* <code>ThreadDeath</code> unless it must do some extraordinary* cleanup operation (note that the throwing of* <code>ThreadDeath</code> causes <code>finally</code> clauses of* <code>try</code> statements to be executed before the thread* officially dies). If a <code>catch</code> clause catches a* <code>ThreadDeath</code> object, it is important to rethrow the* object so that the thread actually dies.* <p>* The top-level error handler that reacts to otherwise uncaught* exceptions does not print out a message or otherwise notify the* application if the uncaught exception is an instance of* <code>ThreadDeath</code>.** @exception SecurityException if the current thread cannot* modify this thread.* @see #interrupt()* @see #checkAccess()* @see #run()* @see #start()* @see ThreadDeath* @see ThreadGroup#uncaughtException(Thread,Throwable)* @see SecurityManager#checkAccess(Thread)* @see SecurityManager#checkPermission* @deprecated This method is inherently unsafe. Stopping a thread with* Thread.stop causes it to unlock all of the monitors that it* has locked (as a natural consequence of the unchecked* <code>ThreadDeath</code> exception propagating up the stack). If* any of the objects previously protected by these monitors were in* an inconsistent state, the damaged objects become visible to* other threads, potentially resulting in arbitrary behavior. Many* uses of <code>stop</code> should be replaced by code that simply* modifies some variable to indicate that the target thread should* stop running. The target thread should check this variable* regularly, and return from its run method in an orderly fashion* if the variable indicates that it is to stop running. If the* target thread waits for long periods (on a condition variable,* for example), the <code>interrupt</code> method should be used to* interrupt the wait.* For more information, see* <a href="{@docRoot}/../technotes/guides/concurrency/threadPrimitiveDeprecation.html">Why* are Thread.stop, Thread.suspend and Thread.resume Deprecated?</a>.*/@Deprecatedpublic final void stop() {stop(new ThreadDeath());}

public static void main(String[] args) {MyThread thread = new MyThread...//.....thread.stop();//....}

/*** Tests whether the current thread has been interrupted. The* <i>interrupted status</i> of the thread is cleared by this method. In* other words, if this method were to be called twice in succession, the* second call would return false (unless the current thread were* interrupted again, after the first call had cleared its interrupted* status and before the second call had examined it).** <p>A thread interruption ignored because a thread was not alive* at the time of the interrupt will be reflected by this method* returning false.** @return <code>true</code> if the current thread has been interrupted;* <code>false</code> otherwise.* @see #isInterrupted()* @revised .*/public static boolean interrupted() {return currentThread().isInterrupted(true);}

/*** Tests whether this thread has been interrupted. The <i>interrupted* status</i> of the thread is unaffected by this method.** <p>A thread interruption ignored because a thread was not alive* at the time of the interrupt will be reflected by this method* returning false.** @return <code>true</code> if this thread has been interrupted;* <code>false</code> otherwise.* @see #interrupted()* @revised .*/public boolean isInterrupted() {return isInterrupted(false);}

/*** Tests if some Thread has been interrupted. The interrupted state* is reset or not based on the value of ClearInterrupted that is* passed.*/private native boolean isInterrupted(boolean ClearInterrupted);

public static boolean interrupted() {return currentThread().isInterrupted(true);}/************************/public boolean isInterrupted() {return isInterrupted(false);}

public class MyThread extends Thread {@Overridepublic void run() {super.run();for (int i = ; i < ; i++) {System.out.println("i=" + (i + ));}}}

public class Run {public static void main(String[] args) {try {MyThread thread = new MyThread();thread.start();Thread.sleep();thread.interrupt();//Thread.currentThread().interrupt();System.out.println("是否停止？="+thread.interrupted());//falseSystem.out.println("是否停止？="+thread.interrupted());//false main線程沒有被中斷!!!　　　　　　//......

public class Run {public static void main(String[] args) {try {MyThread thread = new MyThread();thread.start();Thread.sleep();thread.interrupt();System.out.println("是否停止？="+thread.isInterrupted());//true