Go: "Java concurrent Programming" bis: Thread Break (with code)

Reprint Please specify source:http://blog.csdn.net/ns_code/article/details/17091267

use interrupt () to break the thread

When one thread is running, another thread can call the interrupt () method of the corresponding thread object to break it, and the method simply sets a flag in the target thread that indicates that it has been interrupted and returns immediately. It is important to note that if you simply call the interrupt () method, the thread is not actually interrupted and will continue to execute.

The following code demonstrates the interruption of a dormant thread:

[Java]View PlainCopy

2. Public class Sleepinterrupt extends Object implements runnable{
4. public Void Run () {
6. try{
8. System.out.println ("in Run ()-about to sleep for seconds");
10. Thread.Sleep (20000);
12. System.out.println ("in Run ()-Woke up");
14. }catch (Interruptedexception e) {
16. System.out.println ("in Run ()-interrupted while sleeping");
18. //After processing the interrupt exception, return to the Run () method population,
20. //If there is no return, the thread will not actually be interrupted, it will continue to print the following information
22. return;
24. }
26. System.out.println ("in Run ()-leaving normally");
28. }
34. public static void Main (string[] args) {
36. Sleepinterrupt si = new Sleepinterrupt ();
38. Thread t = new Thread (SI);
40. T.start ();
42. //The main thread sleeps for 2 seconds, thus ensuring that threads just started have a chance to execute for some time
44. try {
46. Thread.Sleep (2000);
48. }catch (Interruptedexception e) {
50. E.printstacktrace ();
52. }
54. System.out.println ("in Main ()-interrupting other thread");
56. //middle thread T
58. T.interrupt ();
60. System.out.println ("in Main ()-leaving");
62. }
64. }

The results of the operation are as follows:

after the main thread starts the new threads, it sleeps for 2 seconds, allowing the new thread to get run time. After the new thread prints the information "about-to-sleep for seconds", and then sleeps for 20 seconds, after about 2 seconds, the main thread notifies the new thread of the break, then the new thread's 20-second sleep is interrupted, causing the interruptexception exception to be thrown, Executes a jump to a catch block, prints out "interrupted while sleeping" information, and immediately returns from the run () method, and then dies, without printing the "leaving normally" message after the catch block. Note: Because of an indeterminate thread plan, the latter two rows of the result may be in reverse order, depending on the primary thread and the new thread which first dies. But the order of the first two lines of information must be as shown. In addition, if the return statement in the Catch block is commented out, the thread will continue to execute until the exception is thrown, without interruption, and the "leaving normally" message will be printed.

pending Interrupts

In the example above, the implementation of the sleep () method checks that the dormant thread is interrupted, it terminates the thread fairly nicely, and throws a Interruptedexception exception. In another case, if the thread is interrupted before calling the sleep () method, then the interrupt is called a pending interrupt, and it throws the interruptedexception exception immediately when the sleep () method is called .

The following code shows the pending interrupt:

[Java]View PlainCopy

2. Public class Pendinginterrupt extends Object {
4. public static void Main (string[] args) {
6. //If a parameter is entered, the current thread (i.e. the main thread) is interrupted in the Mian thread
8. if (Args.length > 0) {
10. Thread.CurrentThread (). interrupt ();
12. }
14. //Get current time
16. Long startTime = System.currenttimemillis ();
18. try{
20. Thread.Sleep (2000);
22. System.out.println ("is not interrupted");
24. }catch (Interruptedexception x) {
26. System.out.println ("was interrupted");
28. }
30. //Calculate the time of intermediate code execution
32. System.out.println ("elapsedtime=" + (System.currenttimemillis ()-startTime));
34. }
36. }

If the pendinginterrupt does not have any command line arguments, then the thread will not be interrupted, the final output time gap should be near 2000 (the time is determined by the system, not accurate), if pendinginterrupt with command-line arguments, the call interrupts the current thread of the code , but the main thread is still running and the final output time gap should be much less than 2000 because the thread has not yet been dormant and is interrupted, so once the sleep () method is called, the information in the catch block is printed immediately. The results of the implementation are as follows:

in this mode, the main thread interrupts itself. In addition to setting the interrupt flag (which is the internal flag of thread) to true, there is no other effect. The thread is interrupted, but the main thread is still running, the main thread continues to monitor the real-time clock and enters the try block, and once the Sleep () method is called, it will notice the existence of the pending interrupt and throw interruptexception. The execution jumps to the catch block and prints the information that the thread is interrupted. Finally, the time difference is calculated and printed.

Use the isinterrupted () method to determine the interrupt stateYou can call the Isinterrupted () method on the thread object to check the interrupt state of any thread. Note here: Once the thread is interrupted, the isinterrupted () method returns True, and once the sleep () method throws an exception, it empties the interrupt flag, and the Isinterrupted () method returns FALSE.
The following code demonstrates the use of the Isinterrupted () method:
[Java]View PlainCopy

2. Public class Interruptcheck extends object{
4. public static void Main (string[] args) {
6. Thread t = Thread.CurrentThread ();
8. System.out.println ("point a:t.isinterrupted () =" + t.isinterrupted ());
10. //Pending interrupt, interrupt itself
12. T.interrupt ();
14. System.out.println ("point b:t.isinterrupted () =" + t.isinterrupted ());
16. System.out.println ("point c:t.isinterrupted () =" + t.isinterrupted ());
20. try{
22. Thread.Sleep (2000);
24. System.out.println ("is not interrupted");
26. }catch (Interruptedexception x) {
28. System.out.println ("was interrupted");
30. }
32. //Throws an exception, clears the interrupt flag and returns false
34. System.out.println ("point d:t.isinterrupted () =" + t.isinterrupted ());
36. }
38. }

The results of the operation are as follows:

Use the thread.interrupted () method to determine the interrupt state

You can use the thread.interrupted () method to check the interrupt state of the current thread (and implicitly reset to false). This method returns true because it is a static method and therefore cannot be used on a particular thread, only the interrupt state of the thread that called it is reported, and if the thread is interrupted and the interrupt state is unclear. Unlike isinterrupted (), it automatically resets the interrupt state to false, the second call to the Thread.interrupted () method, and always returns false unless the thread is interrupted.

The following code demonstrates the use of the Thread.interrupted () method:

[Java]View PlainCopy

2. Public class Interruptreset extends Object {
4. public static void Main (string[] args) {
6. System.out.println (
8. "Point x:thread.interrupted () =" + thread.interrupted ());
10. Thread.CurrentThread (). interrupt ();
12. System.out.println (
14. "Point y:thread.interrupted () =" + thread.interrupted ());
16. System.out.println (
18. "Point z:thread.interrupted () =" + thread.interrupted ());
20. }
22. }

The results of the operation are as follows:

As can be seen from the results, after the current thread breaks itself, at the y Point, the interrupt state is true and is automatically reset to False by thread.interrupted (), then the next call to the method results in false.

Supplement This is supplemented by the use of yield and join methods.
The join method is called with the thread object, and if you call another thread B's Join method in a thread A, thread a waits for thread B to execute before executing. yield can be called directly with the thread class, yielding yields the CPU execution to the same level of thread, and if no thread of the same level waits for the CPU to execute, the thread continues execution.

Go: "Java concurrent Programming" bis: Thread Break (with code)