t.interrupt(),t.isInterrupted(),Thread.interrupted()

最新推荐文章于 2024-07-27 23:59:00 发布
最新推荐文章于 2024-07-27 23:59:00 发布
阅读量2k 收藏 1
点赞数
分类专栏： java基础 文章标签： string join object 数据结构 测试 任务
本文深入探讨Java线程中断机制，包括interrupt()方法的作用、interrupted()与isInterrupted()的区别，如何通过中断终止线程，以及如何避免在循环外部调用wait()方法等关键点。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

原文地址：http://www.blogjava.net/fhtdy2004/archive/2009/08/22/292181.html

在学校的论坛Java版发现很多问关于这样的问题，比如这几个方法有什么区别，想看t.interrupt()方法后线程的中断状态；如何终止一个线程
其实之前已经大部分提及到。现总结一下，然后加上例子，毕竟例子容易理解
http://www.blogjava.net/fhtdy2004/archive/2009/06/08/280728.html中有关interrupt()的解释已经很清楚了

interrupt

public void interrupt()
中断线程。

如果当前线程没有中断它自己（这在任何情况下都是允许的），则该线程的 checkAccess 方法就会被调用，这可能抛出 SecurityException。

如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法，或者该类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻，则其中断状态将被清除，它还将收到一个 InterruptedException。

如果该线程在可中断的通道上的 I/O 操作中受阻，则该通道将被关闭，该线程的中断状态将被设置并且该线程将收到一个 ClosedByInterruptException。

如果该线程在一个 Selector 中受阻，则该线程的中断状态将被设置，它将立即从选择操作返回，并可能带有一个非零值，就好像调用了选择器的 wakeup 方法一样。

如果以前的条件都没有保存，则该线程的中断状态将被设置。

 

抛出：
SecurityException - 如果当前线程无法修改该线程

interrupted

public static boolean interrupted()
测试当前线程是否已经中断。线程的 中断状态 由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。

 

返回：
如果当前线程已经中断，则返回 true；否则返回 false。
另请参见：
isInterrupted()

isInterrupted

public boolean isInterrupted()
测试线程是否已经中断。线程的 中断状态 不受该方法的影响。

 

返回：
如果该线程已经中断，则返回 true；否则返回 false。
另请参见：
interrupted()


t.interrupt()不会中断正在执行的线程，只是将线程的标志位设置成true。但是如果线程在调用sleep(),join(),wait()方法时线程被中断，则这些方法会抛出InterruptedException，在catch块中捕获到这个异常时，线程的中断标志位已经被设置成false了，因此在此catch块中调用t.isInterrupted(),Thread.interrupted()始终都为false,
而t.isInterrupted与Thread.interrupted()的区别是API中已经说明很明显了,Thread.interrupted()假如当前的中断标志为true，则调完后会将中断标志位设置成false

package  threadtest;

 import  java.util.Timer;
 import  java.util.TimerTask;

 class  CanStop  extends  Thread  {

    private int counter = 0;

    public void run() {
        boolean done = false;
        try{
            Thread.sleep(100);//设置成100比主线程中的500要小
        }catch(InterruptedException ie){
            ie.printStackTrace();
            //return;假如要使用interrupt来终止线程则在捕获的InterruptedException中return
        }
        while (counter < 100000 &&!done) {
            System.out.println(counter++);
            //在主线程中调用stoppable.interrupt()之前为false,假如之后没有调用Thread.interrupted()则一直为true,
            //否则为第一次为true,调用Thread.interrupted之后为false
            System.out.println("in thread stoppable.isInterrupted() "+isInterrupted());
            
            //System.out.println("stoppable.isInterrupted() "+Thread.interrupted());////在主线程中调用stoppable.interrupt()之前为false,之后只有第一个会显示为true,之后全为false
            
            //调用Thread.interrupted()一次会清除线程的中断标志位,因此以后都为false
            if(Thread.interrupted()==true){
                try{
                    //Thread.interrupted()会清除中断标志位,显然这里面只会调用一次
                    System.out.println("in thread after Thread.interrupted() "+isInterrupted());
                    sleep(10000);
                }catch(InterruptedException ie){
                    ie.printStackTrace();
                    
                }
            }
        }
    }
    
}

public   class  CheckInterrupt  {
    public static void main(String[] args) {
        final CanStop stoppable = new CanStop();
        stoppable.start();
        new Timer(true).schedule(new TimerTask() {
            public void run() {
                System.out.println("Requesting Interrupt");
                stoppable.interrupt();//不会中断正在执行的线程,原因是因为interrupt()方法只设置中断状态标志位为true
                System.out.println("in timer stoppable.isInterrupted() "+stoppable.isInterrupted());
            }
        }, 500); // run() after 500 milliseconds
    }
}


2,关于interrupte()打断sleep()

package  threadtest;

 // Understanding join().

class  Sleeper  extends  Thread  {
    private int duration;

    public Sleeper(String name, int sleepTime) {
        super(name);
        duration = sleepTime;
        start();
    }

    public void run() {
        try {
            sleep(duration);
        } catch (InterruptedException e) {
            // System.out.println(getName() + " was interrupted. " +
            // "isInterrupted(): " + isInterrupted());
            System.out.println(getName() + " in catch Thread.interrupted(). "
                    + "Thread.interrupted(): " + Thread.interrupted());
            return;
        }
        System.out.println(getName() + " has awakened");
    }
}

class  Joiner  extends  Thread  {
    private Sleeper sleeper;

    public Joiner(String name, Sleeper sleeper) {
        super(name);
        this.sleeper = sleeper;
        start();
    }

    public void run() {
        try {
            sleeper.join();
        } catch (InterruptedException e) {
            //run方法不能Throw CheckedException,要抛只能抛出RuntimeException,也不会被主线程捕获
            //要使主线程能够捕获这个RuntimeException请参见另外一篇文章
            //地址:http://www.blogjava.net/fhtdy2004/archive/2009/08/07/290210.html
            throw new RuntimeException(e);
        }
        System.out.println(getName() + " join completed");
    }
}

public   class  Joining  {

    public static void main(String[] args) {
        Sleeper sleepy = new Sleeper("Sleepy", 1500),
                grumpy = new Sleeper("Grumpy", 1500);
        Joiner  dopey = new Joiner("Dopey", sleepy), 
                doc = new Joiner("Doc",grumpy);
        grumpy.interrupt();
        //doc.interrupt();

    }
}

Sleeper是一个会睡上一段时间的Thread，至于睡多长时间，这要由构造函数的参数决定。Sleeper的run( )的sleep( )可以因时限到期而返回，也可以被interrupt( )打断。catch语句在报告中断的同时，会一并报告isInterrupted( )。当有别的线程调用了本线程的interrupt( )时，会设置一个标记以表示这个这个线程被打断了。当本线程捕获这个异常的时候，会清除这个标志。所以catch语句会永远报告说isInterrupted( )是false。这个标记是用来应付其它情况的，或许在没出异常的情况下，线程要用它来检查自己是不是被中断了。
Joiner是另一个线程，它调用了Sleeper的join( )，所以它要等Sleeper醒过来。main( )创建了两个Sleeper分派给两个Joiner。你会发现，不论Sleeper是被打断还是正常结束，Joiner都会随Sleeper一道结束。





2，如何终止一个线程：

package  test.thread.one;

 import  java.util.Timer;
 import  java.util.TimerTask;

 class  CanStop  extends  Thread  {
    // Must be volatile:
    private volatile boolean stop = false;

    private int counter = 0;

    public void run() {
        while (!stop && counter < 100000) {
            System.out.println(counter++);
        }
        if (stop)
            System.out.println("Detected stop");
    }

    public void requestStop() {
        stop = true;
    }
}

public   class  Stopping  {
    public static void main(String[] args) {
        final CanStop stoppable = new CanStop();
        stoppable.start();
        new Timer(true).schedule(new TimerTask() {
            public void run() {
                System.out.println("Requesting stop");
                stoppable.requestStop();
            }
        }, 500); // run() after 500 milliseconds
    }
}

stop必须是volatile的，这样才能确保run( )方法能看到它(否则它会使用本地的缓存值)。这个线程的"任务"是打印10,000个数字，所以当counter >= 10000或有人要它停下来的时候，它就结束了。注意requestStop( )不是synchronized，因为stop既是boolean(改成true是一个原子操作)又是volatile的。

或者

package  test.thread.three;

 import  java.util.Timer;
 import  java.util.TimerTask;

 class  CanStop  extends  Thread  {
    
    private boolean stop = false;

    private int counter = 0;

    public void run() {
        boolean done = false;
        try{
            Thread.sleep(100);
        }catch(InterruptedException ie){
            ie.printStackTrace();
            //return;假如要使用interrupt来终止线程则在捕获的InterruptedException中return
        }
        while (!getStopRequest() && counter < 100000 &&!done) {
            System.out.println(counter++);
        }
        if (getStopRequest())
            System.out.println("Detected stop");
    }
    
    
    public synchronized boolean getStopRequest(){
        return stop;
    }

    public synchronized void requestStop() {
        stop = true;
    }
}

public   class  Stopping  {
    public static void main(String[] args) {
        final CanStop stoppable = new CanStop();
        stoppable.start();
        new Timer(true).schedule(new TimerTask() {
            public void run() {
                System.out.println("Requesting stop");
                stoppable.requestStop();
            }
        }, 500); // run() after 500 milliseconds
    }
}

 

打断受阻的线程
有时线程受阻之后就不能再做轮询了，比如在等输入，这时你就不能像前面那样去查询旗标了。碰到这种情况，你可以用Thread.interrupt( )方法打断受阻的线程:

 // : c13:Interrupt.java
 //  Using interrupt() to break out of a blocked thread.
import  java.util. * ;
 class  Blocked  extends  Thread  {
  public Blocked() {
    System.out.println("Starting Blocked");
    start();
  }
  public void run() {
    try {
      synchronized(this) {
        wait(); // Blocks
      }
    } catch(InterruptedException e) {
      System.out.println("Interrupted");
    }
    System.out.println("Exiting run()");
  }
}
public   class  Interrupt  {
  static Blocked blocked = new Blocked();
  public static void main(String[] args) {
    new Timer(true).schedule(new TimerTask() {
      public void run() {
        System.out.println("Preparing to interrupt");
        blocked.interrupt();
        blocked = null; // to release it
      }
    }, 2000); // run() after 2000 milliseconds
  }
}   // /



3.避免过多的同步，永远不要在循环外面调用wait

为了避免死锁的危险，在一个被同步的的方法或者代码快中，永远不要放弃对客户的限制。
换句话说，在一个被同步的区域内部，不要调用一个可被改写的公有或受保护的方法（这样的方法往往是一个抽象方法，但偶尔他们也会有一个默认的实现，）从包含该同步区域的类的角度来看，这样的方法是一个外来者alien。这个类不知道该类会做什么事情，也控制不力它。客户可以为这个外来方法提供一个实现，并且在该方法中创建了一个线程，再回调到这个类中。然后，新建的线程试图获取原线程所拥有的那把锁，这样会导致新建的线程被阻塞。如果创建该线程的方法在等待这个线程完成这个任务，则死锁就形成了。


Object.wait方法的作用是使一个线程等待某个条件。它一定是在一个同步区域中被调用，而且该同步区域锁住了被调用的对象。下面是wait方法的标准模式：
synchronized(obj){
      while(<condition does not hold>)
            obj.wait();
      ...//perform action appropriate to condition
}
总是使用wait循环模式来调用wait方法。而不是if来调用。永远不要在循环的外面调用wait。循环被用于等待的前后测试条件

package  effective.java;

 import  java.io.BufferedInputStream;
 import  java.util.LinkedList;
 import  java.util.List;

 public   abstract   class  WorkQueue  {
    
    private final List queue = new LinkedList();
    
    private boolean stopped = false;
    
    StringBuffer sb;
    BufferedInputStream bis;
    
    protected WorkQueue(){
        new WorkerThread2().start();
    }
    
    public final void enqueue(Object workItem){
        synchronized(queue){
            queue.add(workItem);
            queue.notify();
        }
    }
    
    public final void stop(){
        synchronized(queue){
            stopped = true;
            queue.notify();
        }
    }
    
    protected abstract void processItem(Object workItem)throws InterruptedException;
    
    //Broken - invokes alien method from synchronized block
    private class WorkerThread extends Thread{
        public void run(){
            while(true){
                synchronized(WorkQueue.this.queue){
                    try{
                        while(queue.isEmpty() && !stopped){
                            queue.wait();
                        }
                    }catch(InterruptedException ie){
                        ie.printStackTrace();
                        return;
                    }
                    
                    if(stopped)
                        return;
                    Object workItem = queue.remove(0);
                    try{
                        processItem(workItem);//lock held
                    }catch(InterruptedException ie){
                        System.out.println("ddd"+ie);
                        return;
                    }
                }
            }
        }
    }
    
    
    //Alien method outside synchronized block -"open call"
    private class WorkerThread2 extends Thread{
        public void run(){
            while(true){
                Object workItem = null;
                synchronized(WorkQueue.this.queue){
                    try{
                        while(queue.isEmpty() && !stopped){
                            queue.wait();
                        }
                    }catch(InterruptedException ie){
                        return;
                    }
                    
                    if(stopped)
                        return;
                    workItem = queue.remove(0);    
                }
                
                try{
                    processItem(workItem);//No lock held
                }catch(InterruptedException ie){
                    return;
                }
            }
        }
    }
}

 

package  effective.java;

 public   class  DisplayQueue  extends  WorkQueue  {

    @Override
    protected void processItem(Object workItem) throws InterruptedException {
        System.out.println(workItem);
        System.out.println("模拟此线程做耗时工作");
        Thread.sleep(1000);
    }
    
    public static void main(String[] args){
        WorkQueue wq = new DisplayQueue();
        for(int i=0;i<10;i++){
            String s = new String("object_"+i);
            System.out.println("main thread add " + s+" to queue");
            wq.enqueue(s);
            try{
                Thread.sleep(500);
            }catch(InterruptedException ie){
                ie.printStackTrace();
            }
        }
        //wq.stop();
    }

}



class  DeadLockQueue  extends  WorkQueue {

    @Override
    protected void processItem(final Object workItem) throws InterruptedException {
        
        Thread child = new Thread(){
            public void run(){
                //DeadLockQueue.this.enqueue(workItem);
                System.out.println("在将对象入队列 "+workItem);
                enqueue(workItem);
            }
        };
        child.start();
        child.join();//dead lock
        
    }
    
    
}



4.保持可运行线程数量尽可能的少的主要技术是，让每个线程做少量的工作，然后使用Object.wait等待某个条件发生，或者使用Thread.sleep()睡眠一段时间，线程不应该忙－等busy-wait，即反复的检查一个数据结构，以等待某些事件发生。除了使程序易受调度器的变化的影响外，忙等这种做法还会增加处理器的负担
busy-wait

package  effective.java;

 import  java.util.LinkedList;
 import  java.util.List;

 public   abstract   class  WorkQueueBusyWait  {
    
    private final List queue = new LinkedList();
    
    private boolean stopped = false;
    
    protected WorkQueueBusyWait(){
        new WorkThread().start();
    }
    
    public final void enqueue(Object workItem){
        synchronized(queue){
            queue.add(workItem);
        }
    }
    
    public final void stop(){
        synchronized(queue){
            stopped = true;
        }
    }
    
    protected abstract void processItem(Object workitem) throws InterruptedException;
    
    private class WorkThread extends Thread{
        public void run(){
            final Object QUEUE_IS_EMPTY = new Object();
            while(true){
                Object workItem = QUEUE_IS_EMPTY;
                synchronized(queue){
                    if(stopped)
                        return;
                    if(!queue.isEmpty())
                        workItem  = queue.remove(0);
                }
                if(workItem != QUEUE_IS_EMPTY){
                    try{
                        processItem(workItem);
                    }catch(InterruptedException ie){
                        ie.printStackTrace();
                        return;
                    }
                }
            }
        }
    }
}

class  PingPongQueue  extends  WorkQueue {
    volatile int count=0;
    @Override
    protected void processItem(final Object workItem) throws InterruptedException {
        count++;
        WorkQueue recipient = (WorkQueue)workItem;
        recipient.enqueue(this);
    }
    
}

 

package  effective.java;

 public   class  WaitQueuePerf  {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        PingPongQueue q1 = new PingPongQueue();
        PingPongQueue q2 = new PingPongQueue();
        q1.enqueue(q2);
        
        try{
            Thread.sleep(1000);
        }catch(InterruptedException ie){
            ie.printStackTrace();
        }
        
        int count = q1.count;
        try{
            Thread.sleep(1000);
        }catch(InterruptedException ie){
            ie.printStackTrace();
        }
        System.out.println(q1.count-count);
        q1.stop();
        q2.stop();

    }

}
Java-Thread.currentThread().interrupt()
兴趣是最好的老师
01-08 455
因此，在上述场景中，建议始终使用 Thread.currentThread().interrupt() 来确保中断状态的正确传。在某些情况下，Thread.currentThread().interrupt() 是必要的，以确保线程的中断状态被正确传递。这样，中断状态被正确传递，其他代。Thread.currentThread().interrupt() 的主要目的是给当前线程设置中断状态。在改进后的代码中，当 Worker 线程在 Thread.sleep(1000) 时被中断，它会捕获到。
Thread类中interrupt（）、interrupted（）和isInterrupted（）方法详解
热门推荐
qq_39682377的博客
08-06 11万+
首先看看官方说明： interrupt（）方法 其作用是中断此线程（此线程不一定是当前线程，而是指调用该方法的Thread实例所代表的线程），但实际上只是给线程设置一个中断标志，线程仍会继续运行。   interrupted（）方法 作用是测试当前线程是否被中断（检查中断标志），返回一个boolean并清除中断状态，第二次再调用时中断状态已经被清除，将返回一个false。   ...
简述Thread的interrupt()、interrupted()及isInterrupted()的区别
Huangjiazhen711的博客
10-26 557
在java Thread类中，我们会看到interrupt()、interrupted()及isInterrupted()，在大多数情况下，我们都不会使用到它们，但是有一个try {}}那么你知道异常是如何触发的嘛？
t.interrupt()、t.isInterrupted()、Thread.interrupted()
u011042377的博客
03-30 515
1 t.interrupt() 给当前线程 中断标志位置为true 2 t.isInterrupted() 返回当前线程 中断标志 3 Thread.interrupted() 返回当前线程状态，并清除中断标志位，即如果当前线程t.isInterrupted()=true，调用Thread.interrupted()后，再次调用t.isInterrupted()=false ```java ...
Thread.interrupted() 、 Thread.currentThread().isInterrupted() 、Thread.interrupt() 区别
最新发布
05-25
### Java 中 `Thread.interrupt()`、`Thread.currentThread().isInterrupted()` 和 `Thread.interrupted()` 的区别 #### 1. **`Thread.interrupt()`** 该方法用于向目标线程发送一个中断信号，即将线程的中断状态...
《知识点005：Java使用Thread.interrupt 用法》
大大大钢琴
07-27 921
Thread.interrupt()方法用于中断一个线程，‌但它的行为取决于线程当前的状态。‌具体来说，‌Thread.interrupt()方法的行为可以分为两种情况：‌当线程处于运行状态（‌RUNNING）‌或可运行状态（‌RUNNABLE）‌时，‌调用interrupt()方法只是会设置线程的中断标志位，‌没有任何其他作用。‌这意味着，‌如果线程正在执行一个循环或其他长时间运行的任务，‌并且没有定期检查中断标志位，‌那么即使调用了interrupt()方法，‌线程也不会立即停止执行。
《知识点004：Java使用Thread.interrupt() 中断线程》
大大大钢琴
07-27 528
2. 如果本线程是处于阻塞状态：调用线程的wait(), wait(long)或wait(long, int)会让它进入等待(阻塞)状态，或者调用线程的join(), join(long), join(long, int), sleep(long), sleep(long, int)也会让它进入阻塞状态。1、thread.interrupt()方法是中断线程，将会设置该线程的中断状态位，即设置为true，中断的结果线程是死亡、还是等待新的任务或是继续运行至下一步，就取决于这个程序本身。
Thread.interrupted()
以笔为刀的博客
03-30 2900
线程中断 1.线程有自己决定是否中断。其他的线程只能给当前线程设置中断标志位。然后当前线程去检测是否中断。然后自行决定是否中断。 2.Thread.interrupted() 该方法用于检测线程是否中断，以及清除中断标志位。当第二次调用这个方法的时候就会返回false。 3.如果线程被中断，当我们执行Thread.sleep()的时候会抛出中断异常。 Thread thread = new Thread(() -> { while (!Thread.
09之 interrupt()和线程终止方式
大叶子不小的博客
10-10 366
interrupt（）是给线程设置中断标志；interrupted（）是检测中断并清除中断状态；isInterrupted（）只检测中断。还有重要的一点就是interrupted（）作用于当前线程，interrupt（）和isInterrupted（）作用于此线程，即代码中调用此方法的实例所代表的线程。————————————————原文链接：https://blog.csdn.net/qq_39...
Thread.interrupted、Thread.isInterrupted、Thread.interrupt
Pelb的博客
12-22 1301
interrupt() 调用线程的interrupt方法，并不能真正中断线程，只是给线程做了中断状态的标志 在一个线程中调用另一个线程的interrupt()方法，即会向那个线程发出信号——线程中断状态已被设置。至于那个线程何去何从，由具体的代码实现决定。 常见现象：“当调用interrupt方法时，调用对象的线程就会抛出InterruptedException异常”，如果检查线程中断状态...
t.interrupt() t.isInterrupted() Thread.interrupted()区别
lwkhehe的专栏
09-13 1974
t.interrupt()   t.isInterrupted()   Thread.interrupted()区别 1.t.interrupt()设置中断标志位，是实例的方法，线程A持有线程B的句柄，那么线程A可以调用线程B的interrupt()，线程A也可以设置自己的线程为中断状态 2.t.isInterrupted() 判断线程t的中断标志位。如果已经中断返回true，如果未中
源码之Thread.interrupted()
kongkong的专栏
06-28 388
Thread.interrupted() 调用t.interrupt()后，第一次返回true, 第2次及之后都返回false jdk源码 其实都是空方法 public static boolean interrupted() { return currentThread().isInterrupted(true); // ClearInterrupted } private native boolean isInterrupted(boolean ClearInterrupted); JVM_
java Thread的interrupt()、interrupted()、isInterrupted
李习的博客
01-16 444
interrupt() 中断线程 如果当前线程实例被标记为interrupted，则在调用wait、join或者sleep相关方法，并且正在阻塞状态中时，此中断状态会被清除，并触发InterruptedException。 isInterrupted() 判断是否中断了 Thread.interrupted() 判断是否中断了, 如果中断了会清除中断标志位 public void interrupt() { if (this != Thread.currentThread()) .
Thread的Interrupted()方法
Kslient的博客
01-08 7118
在JDK1.0中，可以用stop方法来终止，但是现在这种方法已经被禁用了，改用interrupt方法。 Thread.interrupt()方法不会中断一个正在运行的线程。它的作用是，在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞的状态。更确切的说，如果线程被Object.wait,Thread.join和Thread.sleep三种方法之一阻塞，那么，它将接收到一个中断异常（Inte
Java Thread类中interrupt()、interrupted()、isInterrupted()方法
m0_50163856的博客
03-18 593
interrupt()、interrupted()、isInterrupted()
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值