`

Thread.isInterrupted 的理解

阅读更多

interrupt方法用于中断线程。调用该方法的线程的状态为将被置为"中断"状态。

 

当线程被阻塞的时候,比如被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞时。

调用它的interrput()方法。没有占用CPU运行的线程是不可能给自己的中断状态置位的。这就会产生一个InterruptedException异常,并且不会设置中断状态

 Interrupted的经典使用代码:

 

 //    Interrupted的经典使用代码
    public void run(){    
            try{    
                 ....    
                 while(!Thread.currentThread().isInterrupted()&& more work to do){    
                        // do more work;    
                 }    
            }catch(InterruptedException e){    
                        // thread was interrupted during sleep or wait    
            }    
            finally{    
                       // cleanup, if required    
            }    
    }  
 

 

但是对于sleep,wait,join 要如下处理:

private static void test5() throws Exception{
        Thread t = new Thread (){
            public void run(){  
                while(!Thread.currentThread().isInterrupted()){  
                	try {
						Thread.sleep(4000);
					} catch (InterruptedException e) {
						//这里因为线程已经在运行了,所以可以设置中断状态,
						//并且下次Thread.currentThread().isInterrupted() 会返回true
						Thread.currentThread().interrupt();
						e.printStackTrace();
					}
                    if(Thread.currentThread().isInterrupted()){  
                        System.out.println("Someone interrupted me.");  
                    }  
                    else{  
                        System.out.println("Thread is Going...");  
                    }
                }  
            }  
        }  ;  
        t.start();  
        Thread.sleep(3000);  
        //此时,线程在sleep,虽然被打断,仅仅是抛出异常从sleep中退出,不会设置中断状态
        t.interrupt(); 
	}

private static void test6() throws Exception{
        Thread t = new Thread (){
            public synchronized void  run(){  
                while(!Thread.currentThread().isInterrupted()){  
                	try {
                		System.out.println("wait");
						this.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
						System.out.println();
						//false
						System.out.println(Thread.currentThread().isInterrupted());
						
						//这里因为线程已经在运行了,所以可以设置中断状态,
						//并且下次Thread.currentThread().isInterrupted() 会返回true
						Thread.currentThread().interrupt();
					}
                    if(Thread.currentThread().isInterrupted()){  
                        System.out.println("Someone interrupted me.");  
                    }  
                    else{  
                        System.out.println("Thread is Going...");  
                    }
                }  
            }  
        }  ;  
        t.start();  
        Thread.sleep(3000);  
        //此时,线程在sleep,虽然被打断,仅仅是抛出异常从sleep中退出,不会设置中断状态
        t.interrupt(); 
	}

 

 

下面的案例说明了这个问题:

 

 wait响应中断,会抛出异常,但是不会设置中断状态

/**
	 * wait响应中断,会抛出异常,但是不会设置中断状态
	 */
	private static void testWait() throws Exception {
		Thread t = new Thread(){
			public synchronized void  run() {
				try {
					System.out.println("internal thread running");
					this.wait();
					System.out.println("internal thread over");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				//false
				System.out.println(Thread.currentThread().isInterrupted()); 
			};
		};
		
		t.start();
		SleepUtils.sleep(1000);
		t.interrupt();
		System.out.println(t.isInterrupted());
		System.out.println("Main over");
	}

 

park的被中断后,不会抛出异常,另外会设置中断位

/**
	 * park响应中断,但是不会抛出异常
	 */
	private static void testPark() throws Exception {
		Thread t = new Thread(){
			public void run() {
				System.out.println("internal thread running");
				LockSupport.park(Thread.currentThread());
				System.out.println("internal thread over");
				//true
				System.out.println(Thread.currentThread().isInterrupted()); 
			};
		};
		
		t.start();
		SleepUtils.sleep(3000);
		t.interrupt();
		System.out.println("Main over");
	}

 

sleep 会抛出异常,但是不会设置中断状态

中断之后,再调用sleep 会抛出异常,并清理中断状态 (这里指 Thread.currentThread().interrupt())

/**
	 * sleep响应中断,会抛出异常,设置中断状态
	 * @throws Exception
	 */
	private static void testSleep() throws Exception {
		Thread t = new Thread(){
			public void run() {
				try {
					System.out.println("internal thread running");
					Thread.currentThread().sleep(10000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				//false
				System.out.println("----"+Thread.currentThread().isInterrupted()); 
			};
		};
		
		t.start();
		SleepUtils.sleep(3000);
		t.interrupt();
		System.out.println("Main over");
	}

 

 运行中的线程,中断线程,不会终止线程的执行,只是改变了中断状态

 

/**
	 * 运行中的线程,打断,不会终止线程的执行,只是改变了中断状态
	 * 对于非阻塞中的线程, 只是改变了中断状态
	 */
	private static void test1() throws Exception{
        Thread t = new Thread (){
            public void run(){  
                while(true){  
                    if(Thread.currentThread().isInterrupted()){  
                        System.out.println("Someone interrupted me.");  
                    }  
                    else{  
                        System.out.println("Thread is Going...");  
                    }
                }  
            }  
        }  ;  
        t.start();  
        Thread.sleep(3000);  
        t.interrupt();  
  /**
     分析如上程序的结果: 
    在main线程sleep的过程中由于t线程中isInterrupted()为false所以不断的输出”Thread is going”。
    当调用t线程的interrupt()后t线程中isInterrupted()为true。此时会输出Someone interrupted me.
    而且线程并不会因为中断信号而停止运行。因为它只是被修改一个中断信号而已。

    当我们调用t.interrput()的时候,线程t的中断状态(interrupted status) 会被置位。
    我们可以通过Thread.currentThread().isInterrupted() 来检查这个布尔型的中断状态。
  */
	}
 

 

 如果线程被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞,那么, 

它将接收到一个中断异常;如果线程被上述几种方法阻塞,正确的停止线程方式是设置共享变量,并调用interrupt()

 

private static void test2() throws Exception {
		Thread3 thread = new Thread3();
		System.out.println("Starting thread...");
		thread.start();

		Thread.sleep(3000);

		System.out.println("Asking thread to stop...");

		/*
		 * 如果线程阻塞,将不会检查此变量,调用interrupt之后,线程就可以尽早的终结被阻 塞状 态,能够检查这一变量。
		 */
		thread.stop = true;

		/*
		 * 这一方法实际上完成的是,在线程受到阻塞时抛出一个中断信号,这样线程就得以退 出阻 塞的状态
		 */
		thread.interrupt();

		Thread.sleep(3000);
		System.out.println("Stopping application...");
		System.exit(0);
	}

static class Thread3 extends Thread {
		volatile boolean stop = false;
		public void run() {
			while (!stop) {
				System.out.println("Thread running...");
				try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					// 接收到一个中断异常(InterruptedException),从而提早地终结被阻塞状态
					e.printStackTrace();
					System.out.println("Thread interrupted...");
				}
			}

			System.out.println("Thread exiting under request...");
		}
	}
 

 

 

0
1
分享到:
评论

相关推荐

    Java处理InterruptedException异常的理论与实践

    `Thread.interrupt()`方法用来设置线程的中断标志,而`Thread.isInterrupted()`和`Thread.interrupted()`方法分别用于检查和清除这个中断标志。 处理`InterruptedException`有几种策略。一种常见的做法是重新抛出...

    Java基本功之中断线程的理解[参考].pdf

    Thread.currentThread.isInterrupted() && more work to do) {...}`,当`isInterrupted`为`true`时,循环结束,`run`方法自然结束。 - **策略二**:利用`sleep`的`InterruptedException`,如`while (more work to ...

    JavaThread中断机制共11页.pdf.zip

    Java中的线程中断状态是一种标志,由`Thread.isInterrupted()`和`Thread.interrupted()`两个方法来检查和清除。`isInterrupted()`用于判断线程是否被中断,不会清除中断状态;而`interrupted()`不仅检查中断状态,...

    JavaThread.pdf

    在实际编程中,正确理解和运用Java线程的创建、管理、同步、中断等机制是非常重要的,它们是构建稳定高效Java并发程序的基础。上述知识点涉及了Java线程编程的核心概念,是开发者必须掌握的技能。

    java编程 线程的经典实用案例

    线程可以在运行时检查Thread.currentThread().isInterrupted()来响应中断请求。 ```java while (!Thread.currentThread().isInterrupted()) { // 任务代码 } ``` 7. 守护线程(Daemon):守护线程主要用于为用户...

    Thread类的interrupt(),interrupted(),isInterrupted()1

    在Java多线程编程中,理解`Thread`类中的`interrupt()`、`interrupted()`和`isInterrupted()`方法至关重要,因为它们与线程中断机制紧密相关。线程中断是Java提供的一种协作式中断机制,它并不强制结束线程,而是...

    Android开发笔记之:如何安全中止一个自定义线程Thread的方法

    线程可以通过检查`Thread.currentThread().isInterrupted()`来判断是否已被中断,从而决定是否结束工作。 下面是一个推荐的自定义线程类的示例,展示了如何利用中断机制安全地停止线程: ```java public class ...

    javathread.part104.rar

    线程可以通过检查`isInterrupted()`或`InterruptedException`异常来响应中断请求。 13. **线程Local变量(ThreadLocal)**:为每个线程提供独立的变量副本,确保数据的安全性,常用于存储线程局部状态。 以上只是...

    java通过线程控制程序执行超时(新)

    Java的线程提供了中断机制,通过`Thread.interrupt()`和`Thread.isInterrupted()`方法来控制和检查线程中断状态。在长时间运行的任务中,应定期检查中断标志,一旦检测到中断,及时清理资源并退出。 ```java ...

    javathread.part03.rar

    `javathread.part03.rar`这个压缩包文件很可能包含了关于Java线程深入理解和实践的资源,可能是代码示例、教程文档或者课件。在这个部分,我们将探讨Java线程的一些关键知识点。 1. **线程创建**: Java提供了两种...

    关于Thread讲解

    - `Thread.isInterrupted()`:判断线程是否被中断。 - `Thread.join()`:等待线程结束。 - `Thread.yield()`:使当前线程让出CPU使用权。 - `Thread.setPriority(int priority)`:设置线程优先级。 - **线程...

    javathread.part04.rar

    - `Thread.interrupt()`:标记线程为中断状态,线程可以通过检查`isInterrupted()`或`interrupted()`来响应中断请求。 10. **线程安全的日志和调试**: - 使用适当的日志框架(如Log4j、SLF4J)记录线程信息。 -...

    Thread创建

    if (thread.isInterrupted()) { // 处理中断 } ``` 四、线程池与Executor框架 Java 5引入了ExecutorService和ThreadPoolExecutor,它们提供了更加灵活的线程管理。通过创建线程池,可以复用已存在的线程,避免...

    Android 实现界面刷新的几种方法

    Thread.currentThread().isInterrupted()) { Message message = new Message(); message.what = Activity01.REFRESH; Activity01.this.myHandler.sendMessage(message); try { Thread.sleep(100); } catch ...

    Java 实例 - 获取线程id源代码+详细指导教程.zip

    线程需要在适当的地方检查`Thread.currentThread().isInterrupted()`,并在检测到中断时采取相应措施。 6. **守护线程(Daemon Threads)**: 守护线程是一种特殊的线程,当所有非守护线程结束时,程序会自动退出...

    java线程(中文)

    线程中断是一种协作中断机制,通过Thread.interrupt()方法设置中断标志,其他线程可以通过检查Thread.isInterrupted()或Thread.currentThread().isInterrupted()来响应中断请求。中断不是立即停止线程,而是作为一种...

    线程终止问题

    Thread.currentThread().isInterrupted())`,当发现中断时,循环结束,线程也就终止了。 以下是一个使用 `interrupt` 方法的例子,展示了在阻塞状态下终止线程: ```java public class ThreadInterrupt extends ...

    Android通用多个线程通信管理框架.pdf

    在循环内部,可以根据Thread.currentThread().isInterrupted()的结果来判断线程是否被中断,并据此退出循环。 6. 线程休眠 MyThread中的run方法中使用了Thread.sleep(1000),目的是让线程暂停执行。这在很多情况下...

Global site tag (gtag.js) - Google Analytics