精华内容
下载资源
问答
  • 文章目录官网方法&源码void interrupt()` boolean isInterrupted()` vs `...示例void interrupt()sleep()方法中测试interruptwait()方法中测试interruptjoin方法中测试interruptboolean isInterrupted() 和...

    在这里插入图片描述
    在这里插入图片描述


    官网

    我们看下Java8中Thread类关于interrupt的几个方法

    在这里插入图片描述

    先来看下基本用法,我们后面的例子再该示例上拓展

    package com.artisan.test;
    
    public class ThreadInterruptedDemo {
    
        public static void main(String[] args) {
            // 定义一个线程  死循环 调用start后一直运行
            Thread t = new Thread(() -> {
                while (true) {
                }
            }, "t");
            // 启动线程
            t.start();
    
            // 查看t的状态
            System.out.println("before interrupt status>>>" + t.isInterrupted());
            // interrupt
            t.interrupt();
            // 查看t的状态
            System.out.println("after interrupt status>>>" + t.isInterrupted());
    
        }
    }
    
    
    

    运行

    在这里插入图片描述


    方法&源码

    查看官方的API,可以看到 关于interrupt的 我们可以调用的API 主要有3个

    void	interrupt()
    	----Interrupts this thread.
    static boolean	interrupted()
    	---Tests whether the current thread has been interrupted.
    boolean	isInterrupted()
    	----Tests whether this thread has been interrupted
    
    
    

    void interrupt()

    在这里插入图片描述
    大致意思是说:

    除非当前线程正在中断自身(始终允许),否则将调用此线程的checkAccess方法,这可能导致抛出SecurityException。

    如果在调用Object类的wait(),wait(long)或wait(long,int)方法,或者join(),join(long),join(long,int)方法中阻塞了这个线程,sleep(long)或sleep(long,int),这个类的方法,然后它的中断状态将被清除,它将收到InterruptedException。

    如果在InterruptibleChannel上的I / O操作中阻塞了该线程,则该通道将被关闭,线程的中断状态将被设置,并且线程将收到ClosedByInterruptException。

    如果此线程在Selector中被阻塞,则线程的中断状态将被设置,并且它将立即从选择操作返回,可能具有非零值,就像调用选择器的唤醒方法一样。

    如果以前的条件都不成立,则将设置该线程的中断状态。

    中断不活动的线程不会产生任何影响

    我们来看下源码,我这里标注了下注释

     public void interrupt() {
     
    	    // 如果不是当前线程,抛出SecurityException异常
            if (this != Thread.currentThread())
                checkAccess();
    		// 对blockerLock对象加锁  private final Object blockerLock = new Object(); 
            synchronized (blockerLock) {
                Interruptible b = blocker;
                if (b != null) {
                    interrupt0();           // 调用interrupt0 这个native的方法 :Just to set the interrupt flag
                    b.interrupt(this);
                    return;
                }
            }
            interrupt0();
        }
    
    

    boolean isInterrupted() vs static boolean interrupted()

    写个例子 ,都在注释里了。
    在这里插入图片描述


    方法&示例

    void interrupt()

    sleep()方法中测试interrupt

    package com.artisan.test;
    
    public class ThreadInterruptedDemo {
    
        public static void main(String[] args) throws InterruptedException {
            Thread t = new Thread(() -> {
                while (true) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) { // 捕获InterruptedException
                        System.out.println(Thread.currentThread().getName() + " 接收到打断信号 ");
                        e.printStackTrace();
                    }
                }
            }, "t");
            t.start();
    
            System.out.println("before interrupt status>>>" + t.isInterrupted());
            // interrupt
            t.interrupt();
            System.out.println("after interrupt status>>>" + t.isInterrupted());
    
        }
    }
    
    
    

    在这里插入图片描述
    虽然捕获了InterruptedException,但是该程序依旧还是运行,并没有退出


    wait()方法中测试interrupt

    package com.artisan.test;
    
    public class ThreadInterruptedDemo {
    
        private static  final Object MONITOR = new Object();
    
    
        public static void main(String[] args) throws InterruptedException {
            Thread t = new Thread(() -> {
                while (true) {
                    // 使用wait的时候,必须要使用synchronized 加锁
                    synchronized (MONITOR){
                        try {
                            MONITOR.wait(100);
                        } catch (InterruptedException e) {
                            System.out.println(Thread.currentThread().getName() + " 接收到打断信号 ");
                            e.printStackTrace();
                        }
                    }
                }
            }, "t");
            t.start();
    
            System.out.println("before interrupt status>>>" + t.isInterrupted());
            // interrupt
            t.interrupt();
            System.out.println("after interrupt status>>>" + t.isInterrupted());
    
        }
    }
    
    
    

    使用wait的时候,必须要使用synchronized 加锁,这里对一个Object对象加锁

    虽然捕获了InterruptedException,但是该程序依旧还是运行,并没有退出
    在这里插入图片描述


    join方法中测试interrupt

    这个比较有意思,我们来逐步的测试下

    先搭个基本的架子

    package com.artisan.test;
    
    public class ThreadInterruptedDemo {
    
        public static void main(String[] args)  {
            Thread t = new Thread(() -> {
                while (true) {
    
                }
            }, "t");
    
            // 启动
            t.start();
    
            // join
            try {
                t.join();
            } catch (InterruptedException e) {
                System.out.println("收到中断信号...");
                e.printStackTrace();
            }
    
            System.out.println("这里永远都不会执行到,因为t是个死循环... ");
    
        }
    }
    
    

    因为一旦 join方法执行了以后,后面的代码都会被阻塞住,因此必须要在join之前开辟另外一个线程

    为了直观,我们直接贴图吧

    在这里插入图片描述

    运行结果:

    在这里插入图片描述
    **并没有出现我们期望的InterruptedException **,w t f…

    我们来分析下,上面的两个例子 。

    sleep 我们sleep的是 t 线程,我们调用了t.interrupt,收到了InterruptedException
    wait 我们wait的也是t 线程,我们调用了t.interrupt,收到了InterruptedException

    但是我们join的时候,t.join ,这个时候join的不是线程t,是join的main线程 ,所以必须用main线程来调用interrupt , 改造下

    在这里插入图片描述

    运行日志

    在这里插入图片描述


    boolean isInterrupted() 和 static boolean interrupted()

    在这里插入图片描述


    展开全文
  • interrupt用法

    千次阅读 2019-07-13 22:08:40
    void interrupt()方法: 中断线程,例如当线程A运行时,线程B可以调用线程A的interrupt()方法来设置线程A的中断标志为true并立即返回。设置标志仅仅是设置标志,线程A实际上并没有被中断,它会继续往下执行。如果线程...

    java中的线程中断是一种线程间的协作模式,通过设置线程的中断标志并不能直接终止该线程的执行,而是被中断的线程根据中断状态自行处理。

    void interrupt()方法:
    中断线程,例如当线程A运行时,线程B可以调用线程A的interrupt()方法来设置线程A的中断标志为true并立即返回。设置标志仅仅是设置标志,线程A实际上并没有被中断,它会继续往下执行。如果线程A因为调用了wait系列的函数,join方法或者sleep方法而被阻塞挂起,这时候若是线程B调用线程A的interrupt()方法,线程A会在调用这些方法的地方抛出InterruptedException异常而返回。

    boolean isInterrupted()方法:
    检查当前线程是否被中断,如果是返回true,否则返回false

    isInterrupted()的内部

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

    false表示不清除中断状态

    boolean interrupted()方法:
    检测当前线程是否中断,如果是返回true,否则返回false。与isInterrupted不同的是,该方法如果发现当前线程被中断,则会清除中断标志,也就是如果第一次调用是true,再次调用返回的就是false,因为之前的中断状态被清除了。
    并且该方法是static方法,可以通过Thread类直接调用。

    目前已知的Thread类的静态方法有sleep(),yield(),interrupted()

    interrupted的内部

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

    true表示清除中断标志,这里是调用当前线程的isInterrupted方法获取当前线程的中断状态,而不是调用interrupted的实例对象的中断状态
    在这里插入图片描述

    使用中断的例子

     public static void main(String[] args) throws InterruptedException {
    
            Thread t = new Thread(() -> {
    
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println(Thread.currentThread() + "  hello");
                }
    
            });
            t.start();
            
            //中断子线程
            System.out.println("main thread interrupt thread");
            t.interrupt();
            //等待子线程执行完毕
            t.join();
    
            System.out.println("main is over");
    
        }
    

    输出如下

    main thread interrupt thread
    Thread[Thread-0,5,main]  hello
    main is over
    

    设计思路:
    在线程里面使用了一个while循环来进行工作,如果不是中断状态就继续执行,如果是就跳出循环,跳出循环之后,这个线程就执行结束了,自然消亡。

    try {
              while (!Thread.currentThread().isInterrupted() && more work todo){
                        //do more work
                    }
                } catch (InterruptedException e) {
                    //thread was interrupted during sleep or wait
                } finally {
                    //cleanup,if required
                }
    

    另一种场景:
    当线程为了等待一些特定的条件,会调用sleep或者wait或者join来阻塞挂起当前线程。 比如说有某个任务要3秒后才会到来,于是调用了sleep(3000)等待,那么3秒后线程才会激活,但是有可能3秒内那个需要处理的任务已经到了,这个时候继续阻塞下去就浪费了时间,可以用interrupter让这个线程从阻塞状态打断。

    比如说:

    public static void main(String[] args) throws InterruptedException {
    
            Thread t = new Thread(() -> {
    
                try {
                    System.out.println("threadOne begin sleep for 2000 seconds");
                    Thread.sleep(200000);
                    System.out.println("threadOne awaking");
                } catch (InterruptedException e) {
                    System.out.println("threadOne is interrupted while sleeping");
                    return;
                }
            });
    
    
            t.start();
    
            Thread.sleep(1000);
            //中断子线程 让它从休眠中返回
            System.out.println("main thread interrupt thread");
            t.interrupt();
            //等待子线程执行完毕
            t.join();
    
            System.out.println("main is over");
    
        }
    
    

    本了应该要休眠200秒,然后被中断了 ,捕获到异常之后,进行catch处的逻辑。

    展开全文
  • interrupt的实际用法

    2016-11-17 13:14:00
     interrupt()方法是在运行的线程中进行对该线程打上中断标记,只是告诉线程是,这个线程可以被中断,但是不会去进行中断操作,线程会保持执行,直到线程的代码执行完毕为止。  这个是线程方法: public ...

           interrupt()方法是在运行的线程中进行对该线程打上中断标记,只是告诉线程是,这个线程可以被中断,但是不会去进行中断操作,线程会保持执行,直到线程的代码执行完毕为止。

            这个是线程方法:

    public class MyService extends Thread{
    	  
    	public void run()
    	{
    		super.run();
    		for(int i=0;i < 50000;i++)
    		{
    			System.out.println("是否被中断:"+this.isInterrupted());
    			if(this.isInterrupted())
    			{
    				System.out.println("已经是停止状态了");
    				break;
    			}
    			System.out.println("i="+ (i+1));
    		}
    		System.out.println("我被输出");
    	}
    }

    这个是主线程main方法:

    public class Run {
    	public static void main(String[] args) {
    		try {
    		MyService thread =new MyService();
    		thread.start();		
    		 Thread.sleep(10);
    		thread.interrupt();
    		System.out.println("是否停止1:"+ thread.interrupted());
    		System.out.println("是否停止2:"+ thread.interrupted());
    		System.out.println("end!");
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    	}
    }

    下面是运行结果:

    是否被中断:false
    i=253
    是否被中断:true
    是否停止1:false
    是否停止2:false
    end!
    已经是停止状态了

    所以要想真正的中断一个线程,需要进行判断方法boolean interrupted()进行判断。

     

    最后讲一下:

     中断线程。如果线程在调用 Object 类的 wait()wait(long) 或 wait(long, int) 方法,或者该类的 join()join(long)join(long, int)sleep(long) 或 sleep(long, int) 方法

      过程中受阻,则其中断状态将被清除,它还将收到一个 InterruptedException

        进行提前进行结束此状态,并进行抛出InterruptedException异常。 

    转载于:https://my.oschina.net/u/1784495/blog/789641

    展开全文
  • [Java]interrupt()用法

    2019-07-26 15:34:37
    Thread#interrupt()的作用其实也不是中断线程,而是通知线程应该中断了,具体来说,当对一个线程调用interrupt() 时: 如果线程处于被阻塞状态(例如处于sleep, wait, join 等状态),那么线程将立即退出被阻塞...

    一、源码阅读

    1 interrupt()

    Thread#interrupt()的作用其实也不是中断线程,而是通知线程应该中断了,具体来说,当对一个线程调用interrupt() 时:

    • 如果线程处于被阻塞状态(例如处于sleep, wait, join 等状态),那么线程将立即退出被阻塞状态,并抛出一个InterruptedException异常,仅此而已。

    • 如果线程处于正常活动状态,那么会将该线程的中断标志设置为true,仅此而已。被设置中断标志的线程将继续正常运行,不受影响。

    interrupt() 并不能真正的中断线程,需要被调用的线程自己进行配合才行,在正常运行任务时,经常检查本线程的中断标志位,如果被设置了中断标志就自行停止线程。具体到底中断还是继续运行,应该由被通知的线程自己处理。

    public void interrupt() {
    
            if (this != Thread.currentThread())
    
                checkAccess();
    
     
    
            synchronized (blockerLock) {
    
                Interruptible b = blocker;
    
                if (b != null) {
    
                    interrupt0();           // Just to set the interrupt flag
    
                    b.interrupt(this);
    
                    return;
    
                }
    
            }
    
            interrupt0();  // Just to set the interrupt flag
    
        }
    

    2 interrupted()

    检查当前中断标识(即查看当前中断信号是true还是false),并清除中断信号。一般处理过中断以后使用此方法。

        public static boolean interrupted() {
    
            return currentThread().isInterrupted(true);
    
        }
    
        /**
    
         * 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);
    

    3 isInterrupted()

    检查当前中断标识(即查看当前中断信号是true还是false)

    public boolean isInterrupted() {
    
        return isInterrupted(false);
    
    }
    

    二 、示例

    以下示例展示了通过isInterrupted()、interrupt()如何终止执行中的线程,如下所示代码中中创建了两个线程(thread1、thread2),thread1每隔500ms数数一次,thread2休眠一段时间以后中断thread1,thread1将会终止。

    import java.util.Random;
    
    /**
     * @author Leon
     * @create 2019-07-26-15:02
     */
    public class Thread1 {
        public static void main(String[] args) {
            Thread thread1 = new Thread(() -> {
                try {
                    int i = 0;
                    while (!Thread.currentThread().isInterrupted()) {
                        Thread.sleep(500);
                        System.out.println("couting... i=" + i);
                        i++;
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    System.out.println("thread1 interrupted");
                }
            });
            Thread thread2 = new Thread(() -> {
                Random random = new Random();
                try {
                    long time = random.nextInt(3000) + 1000;
                    Thread.sleep(time);
                    System.out.println("interrupt thread1");
                    thread1.interrupt();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            thread1.start();
            thread2.start();
        }
    }
    
    
    

    提示:如果代码报错提示Lambda expressions are not supported at language level ‘5’,则修改modules如下所示:
    在这里插入图片描述
    运行结果:
    在这里插入图片描述
    参考文章:https://yq.aliyun.com/articles/680328

    展开全文
  • interrupt 0 using 1 的用法

    千次阅读 2014-12-02 09:42:53
    void INT0()interrupt 0 using 1 {.... ..... } interrupt 0 指明是外部中断0; interrupt 1 指明是定时器中断0; interrupt 2 指明是外部中断1; interrupt 3 指明是定时器中断1; interrupt 4 指明是串行口中断...
  • void INT0()interrupt 0 using 1 {.... ..... } interrupt 0 指明是外部中断0; interrupt 1 指明是定时器中断0; interrupt 2 指明是外部中断1; interrupt 3 指明是定时器中断1; interrupt 4 指明是串行口中断...
  • void INT0()interrupt 0 using 1 {.... ..... } interrupt 0 指明是外部中断0; interrupt 1 指明是定时器中断0; interrupt 2 指明是外部中断1; interrupt 3 指明是定时器中断1; interrupt 4 指明是...
  • void INT0()interrupt 0 using 1 {.... ..... } interrupt 0 指明是外部中断0; interrupt 1 指明是定时器中断0; interrupt 2 指明是外部中断1; interrupt 3 指明是定时器中断1; interrupt 4 指明是...
  • 如果需要停止一个处于等待状态下的线程,那么我们需要通过变量配合notify方法或者interrupt()来使用  *   * */ 运行结果:main0 main1 main2 ...main80 main81 main82 main83 收到异常了...main99 ...
  • thread.interrupt() ; System. out .println( "线程是否中断:" + thread.isInterrupted()) ; Thread. sleep ( 3000 ) ; System. out .println( "Stopping application..." ) ; } public void ...
  • t.interrupt(); } } 需要注意以下两个方法的区别: boolean isInterrupted() 测试线程是否已经中断。线程的中断状态 不受该方法的影响。 static boolean interrupted() 测试当前线程是否...
  • 1、先把代码占上再来说明问题. class Demo implements Runnable{  public void run(){  try{  System.out.println("**********************in run()-这个线程休眠...这就是简单的interrupt()方法的简单用法!!!
  • 一个线程join另一个线程,(包括和interrupt互动的用法)3---马克-to-win java视频
  • C语言在8051单片机上的扩展(interrupt、using关键字的用法)直接访问寄存器和端口 定义sfr P0 0x80 sfr P1 0x81 sfr ADCON; 0xDEsbit EA 0x9F 操作ADCON = 0x08;  P1 = 0xFF; io_status = P0 ; EA = 1; 在...
  • 1)interrupt是Thread对象的方法,用于修改线程的打断状态为true(可以用isInterrupted()来获取),除此之外未做任何其他事,所以interrupt并不会去真正的打断某个线程的运行状态或杀死某个线程; 但是,当本线程在...
  • 我想代码是非常容易解释这个问题的了。下文会给出总结。 ... 直接来一段小代码吧: ...public class Interrupt { public static void main(String[] args) { Thread t = new Thread(new Worker()); t.start(); t...
  • public void interrupt() 中断调用该方法的线程,此处的中断不是线程就会done,而只是添加中断标志位,线程该往下执行还是会执行的 public boolean isinterrupted() 测试调用该方法的线程是否已被中断,不会清除...
  • **注意,如果线程 成功执行了 interrupt() 将 该线程致为中断状态,即唤醒了线程,那么 当第一次调用 interrupted() 的时候 会返回会 true , 如果再次调用就是 false 了 测试当前线程是否已经中断。线程的中断状态 ...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 186
精华内容 74
关键字:

interrupt用法