精华内容
下载资源
问答
  • interrupt方法

    2019-03-24 09:55:14
    1、interrupt方法 使用interrupt()中断线程 当一个线程运行时,另一个线程可以调用对应的Thread对象的interrupt()方法来中断它,该方法只是在目标线程中设置一个标志,表示它已经被中断,并立即返回。这里需要...

    转载:https://blog.csdn.net/qq_33797928/article/details/79450208

    1、interrupt方法

           使用interrupt()中断线程

           当一个线程运行时,另一个线程可以调用对应的Thread对象的interrupt()方法来中断它,该方法只是在目标线程中设置一个标志,表示它已经被中断,并立即返回。这里需要注意的是,如果只是单纯的调用interrupt()方法,线程并没有实际被中断,会继续往下执行。

    
    public class SleepInterrupt extends Object implements Runnable{
    
        @Override
        public void run() {
    
            try {
                System.out.println("in run() - about to sleep for 20 seconds");
                Thread.sleep(20000);
                System.out.println("in run() - woke up");
            } catch (InterruptedException e) {
                System.out.println("in run() - interrupted while sleeping");
                return;
            }
            System.out.println("in run() - leaving normally");
        }
    
        public static void main(String[] args) {
            SleepInterrupt si = new SleepInterrupt();
            Thread t = new Thread(si);
            t.start();
            //住线程休眠2秒,从而确保刚才启动的线程有机会执行一段时间
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("in main() - interrupting other thread"); 
            //中断线程t
            t.interrupt();
            System.out.println("in main() - leaving");
        }
    }   //运行结果如下:
    in run() - about to sleep for 20 seconds
    in main() - interrupting other thread
    in main() - leaving
    in run() - interrupted while sleeping

           主线程启动新线程后,自身休眠2秒钟,允许新线程获得运行时间。新线程打印信息“about to sleep for 20 seconds”后,继而休眠20秒钟,大约2秒钟后,main线程通知新线程中断,那么新线程的20秒的休眠将被打断,从而抛出InterruptException异常,执行跳转到catch块,打印出“interrupted while sleeping”信息,并立即从run()方法返回,然后消亡,而不会打印出catch块后面的“leaving normally”信息。 另外,如果将catch块中的return语句注释掉,则线程在抛出异常后,会继续往下执行,而不会被中断,从而会打印出”leaving normally“信息。

            请注意:由于不确定的线程规划,上图运行结果的后两行可能顺序相反,这取决于主线程和新线程哪个先消亡。但前两行信息的顺序必定如上图所示。

    2、待决中断:

            在上面的例子中,sleep()方法的实现检查到休眠线程被中断,它会相当友好地终止线程,并抛出InterruptedException异常。另外一种情况,如果线程在调用sleep()方法前被中断,那么该中断称为待决中断,它会在刚调用sleep()方法时,立即抛出InterruptedException异常。

    
    public class PendingInterrupt extends Object{
    
        public static void main(String[] args) {
            //如果输入了参数,则在main线程中中断当前线程(即main线程)
            if(args.length > 0){
                Thread.currentThread().interrupt();
            }
            //获取当前时间
            long startTime = System.currentTimeMillis();
            try {
                Thread.sleep(2000);
                System.out.println("was NOT interrupted");
            } catch (InterruptedException e) {
                System.out.println("was interrupted");
            }
            //计算中间代码执行的时间
            System.out.println("elapsedTime=" + (System.currentTimeMillis() - startTime));
        }
    }
    

           如果PendingInterrupt不带任何命令行参数,那么线程不会被中断,最终输出的时间差距应该在2000附近(具体时间由系统决定,不精确),如果PendingInterrupt带有命令行参数,则调用中断当前线程的代码,但main线程仍然运行,最终输出的时间差距应该远小于2000,因为线程尚未休眠,便被中断,因此,一旦调用sleep()方法,会立即打印出catch块中的信息。执行结果如下:

    was NOT interrupted
    elapsedTime=2001

            这种模式下,main线程中断它自身。除了将中断标志(它是Thread的内部标志)设置为true外,没有其他任何影响。线程被中断了,但main线程仍然运行,main线程继续监视实时时钟,并进入try块,一旦调用sleep()方法,它就会注意到待决中断的存在,并抛出InterruptException。于是执行跳转到catch块,并打印出线程被中断的信息。最后,计算并打印出时间差。

    3、使用isInterrupted()方法判断中断状态

           可以在Thread对象上调用isInterrupted()方法来检查任何线程的中断状态。这里需要注意:线程一旦被中断,isInterrupted()方法便会返回true,而一旦sleep()方法抛出异常,它将清空中断标志,此时isInterrupted()方法将返回false。
     

    public class InterruptCheck extends Object{
    
        public static void main(String[] args) {
            Thread t = Thread.currentThread();
            System.out.println("Point A: t.isInterrupted()=" + t.isInterrupted());  
            //待决中断,中断自身  
            t.interrupt();  
            System.out.println("Point B: t.isInterrupted()=" + t.isInterrupted());  
            System.out.println("Point C: t.isInterrupted()=" + t.isInterrupted());  
    
            try {
                Thread.sleep(2000);
                System.out.println("was NOT interrupted");  
            } catch (InterruptedException e) {
                System.out.println("was interrupted");  
            }
            //跑出异常后,会清除中断标志,这里会返回false
            System.out.println("Point D: t.isInterrupted()=" + t.isInterrupted());
        }
    }  //运行结果如下:
    
    Point A: t.isInterrupted()=false
    Point B: t.isInterrupted()=true
    Point C: t.isInterrupted()=true
    was interrupted
    Point D: t.isInterrupted()=false

    4、使用Thread.interrupted()方法判断中断状态

            可以使用Thread.interrupted()方法来检查当前线程的中断状态(并隐式重置为false)。又由于它是静态方法,因此不能在特定的线程上使用,而只能报告调用它的线程的中断状态,如果线程被中断,而且中断状态尚不清楚,那么,这个方法返回true。与isInterrupted()不同,它将自动重置中断状态为false,第二次调用Thread.interrupted()方法,总是返回false,除非中断了线程。
     

    public class InterruptReset extends Object{
        public static void main(String[] args) {
            System.out.println(  
                    "Point X: Thread.interrupted()=" + Thread.interrupted());  
                Thread.currentThread().interrupt();  
                System.out.println(  
                    "Point Y: Thread.interrupted()=" + Thread.interrupted());  
                System.out.println(  
                    "Point Z: Thread.interrupted()=" + Thread.interrupted());  
        }
    }
    //运行结果
    Point X: Thread.interrupted()=false
    Point Y: Thread.interrupted()=true
    Point Z: Thread.interrupted()=false
    

            从结果中可以看出,当前线程中断自身后,在Y点,中断状态为true,并由Thread.interrupted()自动重置为false,那么下次调用该方法得到的结果便是false。

    展开全文
  • Interrupt方法结束线程

    2020-12-21 20:22:54
    4.1.5.3. Interrupt 方法结束线程使用interrupt()方法来中断线程有两种情况: ...通常很多人认为只要调用interrupt方法线程就会结束,实际上是错的, 一定要先捕获InterruptedException异常之后通过break来跳
  • interrupt方法一.interrupt方法1.例12.例23.例34.例4 一.interrupt方法 结束线程在调用Object类的wait方法或该类的join方法、sleep方法过程中的阻塞状态,并在调用wait、join和sleep方法处产生InterruptedException...

    一.interrupt方法

    结束线程在调用Object类的wait方法或该类的join方法、sleep方法过程中的阻塞状态,并在调用wait、join和sleep方法处产生InterruptedException异常

    1.例1

    import java.util.Date;
    
    public class Test {
    
    	public static void main(String[] args) {
    		TimeThread timeThread = new TimeThread();//创建了一个线程
    		timeThread.start();//调用start()方法,使timeThread线程就绪
    		try {
    			Thread.sleep(10000);//为了看出interrupt()方法的效果,停顿10s
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		timeThread.interrupt();//中断timeThread线程,在timeThread线程阻塞处爆发异常并处理该异常,处理完后程序向下执行,打印输出date
    	}
    }
    
    class TimeThread extends Thread{
    
    	@Override
    	public void run() {
    		while (true) {
    			Date date = new Date();
    			try {
    				sleep(60000);//能直接使用sleep()方法,因为TimeThread继承自Thread类,继承了该类的方法
    				System.out.println(date);//不执行,因为调用interrupt方法爆发异常后,直接由e.printStackTrace();处理异常,所以try里的语句不再执行
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    			System.out.println(date);//处理完异常后,打印输出该句话
    		}
    	}
    }
    

    执行后结果在这里插入图片描述

    2.例2

    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    class TimeThread extends Thread {
    
    	public void run() {
    		SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss:sss");
    		String beforeTime = sdf.format(new Date());
    		System.out.println("beforeTime:"+beforeTime);//打印输出beforeTime:时间
    		try {
    			sleep(30000);// 30秒后执行后面代码,timeThread线程阻塞
    			//timeThread.interrupt()该方法调用后,中断阻塞,该处爆发异常
    		} catch (Exception e) {
    			System.out.println("程序捕获了InterruptedException异常!");//处理异常,打印输出
    		}
    		String afterTime = sdf.format(new Date());
    		System.out.println("afterTime:"+afterTime);//打印afterTime:时间
    	}
    }
    
    public class Program {
    	public static void main(String[] args) {//主线程
    		TimeThread timeThread = new TimeThread();//创建timeThread线程
    		timeThread.start();//timeThread线程就绪
    		try{
    			Thread.sleep(1000);//主线程阻塞1s
    		}catch(InterruptedException e){
    			e.printStackTrace();
    		}
    		timeThread.interrupt();
    	}
    }
    

    打印结果
    在这里插入图片描述
    理论上beforeTime和afterTime应该相差30s,但是因为该线程类执行1s后调用了interrupt方法使得该线程提前中断了阻塞状态,导致beforeTime和afterTime不相差30s

    3.例3

    class CounterThread extends Thread {
    
    	Object lockObj;//定义一个全局变量
    
    	public CounterThread(Object lockObj) {
    		this.lockObj = lockObj;//给全局变量赋值
    	}
    
    	@Override
    	public void run() {
    		synchronized (lockObj) {
    			System.out.println("计数器线程正在执行......");
    			try {
    				lockObj.wait();//当线程执行该行代码后,线程进入阻塞状态;但由于10秒后主线程执行了“counterThread.interrupt();”代码使得该线程阻塞状态结束
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    }
    
    public class Test {
    
    	public static void main(String[] args) {
    		Object lockObj = new Object();//创建lockObj对象
    		CounterThread counterThread = new CounterThread(lockObj);//创建counterThread线程,调用CounterThread的构造方法,将lockObj传进去
    		counterThread.start();//counterThread调用start方法,就绪
    		try {
    			Thread.sleep(10000);//停顿10s
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		counterThread.interrupt();//结束counterThread线程的阻塞状态
    	}
    }
    

    在这里插入图片描述

    4.例4

    import java.util.Date;
    
    class TimeThread extends Thread{
    	
    	@Override
    	public void run() {//计数器线程进入阻塞状态后,时间线程获得了CPU的使用权,进入运行状态
    		for(int i=0;i<=2; i++){
    			System.out.println("时间线程:"+new Date());
    			try {
    				Thread.sleep(10000);
    			} catch (InterruptedException e) {
    				e.printStackTrace();
    			}//时间线程执行完至少需要30s
    		}
    	}
    }
    
    class CounterThread extends Thread {
    	
    	private TimeThread timeThread;
    	
    	public CounterThread(TimeThread timeThread){
    		this.timeThread = timeThread;
    	}
    	//计数器线程抢占到CPU的资源,优先进入运行状态
    	@Override
    	public void run() {
    		for(int i=1;i<=3; i++){
    			if(i==2){
    				try {
    					timeThread.join();//计数器线程进入阻塞状态,时间线程进入就绪状态
    				} catch (InterruptedException e) {
    					System.out.println("计数器线程提前结束阻塞状态");
    				}
    			}
    			System.out.println("计数器线程:"+i);
    		}
    	}
    }
    
    public class Program {
    	public static void main(String[] args) {//主线程
    		TimeThread timeThread = new TimeThread();//创建timeThread线程
    		timeThread.start();//timeThread线程就绪
    		CounterThread counterThread = new CounterThread(timeThread);//创建counterThread线程
    		counterThread.start();//counterThread线程就绪
    		try {
    			Thread.sleep(15000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		counterThread.interrupt();//时间线程至少需要消耗30秒才能结束,而15秒后计数器线程调用了interrupt方法致使该计数器线程提前结束阻塞状态
    	}
    }
    

    执行结果
    在这里插入图片描述

    展开全文
  • 关于线程interrupt方法解析 1 interrupt方法的原理 Interrupt方法是用于线程之间的通信。 在线程a中调用b线程的b.interrupt方法,就好像a像b打了个招呼,说b你可以停下来了,但是b停不停下来得看b自己的代码。 2 ...

    关于线程interrupt方法解析
    1 interrupt方法的原理
    Interrupt方法是用于线程之间的通信。
    在线程a中调用b线程的b.interrupt方法,就好像a像b打了个招呼,说b你可以停下来了,但是b停不停下来得看b自己的代码。
    2 interrupt方法使用举例
    2.1调用interrupt方法,并不会让线程停止

    public class MyThread extends Thread{
    	@Override
    	public void run(){
    		for(int i=0;i<500000;i++){
    			System.out.println(i);
    		}
    		System.out.println("循环之后,线程是否会停止");
    	}
    }
    public class Run {
    	public static void main(String[] args) throws InterruptedException {
    		MyThread m = new MyThread();
    		m.start();
    		m.interrupt();
    		Thread.sleep(2000);
    		System.out.println("end");
    	}
    }
    
    

    结果
    在这里插入图片描述
    2.2调用interrupt方法,需要结合isinterrupted、interrupted方法的判断让其结束

    public class MyThread2 extends Thread{
    	@Override
    	public void run(){
    		for(int i=0;i<500000;i++){
    			if(this.interrupted()){
    				System.out.println("已经停止状态我要退出");
    				break;
    			}
    			System.out.println(i);
    		}
    		System.out.println("循环之后,线程是否会停止");
    	}
    }
    public class Run {
    	public static void main(String[] args) throws InterruptedException {
    		MyThread2 m = new MyThread2();
    		m.start();
    		//休眠2秒
    		Thread.sleep(2000);
    		m.interrupt();
    		Thread.sleep(2000);
    		System.out.println("end");
    	}
    }
    
    

    结果
    在这里插入图片描述从结果看,interrupted方法只是起一个标志的作用,让程序跳出循环,并不能停止线程,毕竟打印了“循环之后,线程是否会停止”

    总结是interrupt方法不能让线程停止,只能改变线程的某个状态,我们根据这个状态自己分析是否要结束线程。

    展开全文
  • interrupt方法打断线程demo

    千次阅读 2020-11-21 20:08:21
    interrupt方法打断线程demo1.打断非阻塞状态的线程2.打断阻塞状态的线程 1.打断非阻塞状态的线程 package com.demo; public class InterruputDemo { public static void main(String[] args) throws ...

    1.打断非阻塞状态的线程

    package com.demo;
    
    public class InterruputDemo {
    
        public static void main(String[] args) throws InterruptedException {
            demo1();
        }
    
        /**
         *1.在main线程中调用子线程的interrupt方法,子线程中无阻塞方法
         */
        private static void demo1() throws InterruptedException {
            //子线程
            Thread t2 = new Thread(() -> {
                int count = 0;
                //开始时,中断标志为false,进入循环
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("子线程运行中。。。" + count++);
                    System.out.println("子线程运行中。。。1");
                    System.out.println("子线程运行中。。。2");
                    System.out.println("子线程运行中。。。3");
                    System.out.println("子线程运行中。。。4");
                    System.out.println("子线程运行中。。。5");
                    System.out.println("子线程运行中。。。6");
                }
                //当main中调用了interrupt,中断标志变为true,退出循环
                System.out.println("子线程中断标志="+Thread.currentThread().isInterrupted());
            });
            t2.start();
            //主线程
            int count = 0;
            while (true) {
                //睡眠1秒,等待子线程进入睡眠
                Thread.sleep(1000);
                t2.interrupt();
                System.out.println("main运行中。。。" + count++);
            }
        }
    }
    

    运行结果:

    子线程运行中。。。6
    子线程运行中。。。7333
    子线程运行中。。。1
    子线程运行中。。。2
    子线程运行中。。。3
    子线程运行中。。。4
    子线程运行中。。。5
    子线程运行中。。。6
    子线程运行中。。。7334
    子线程运行中。。。1
    子线程运行中。。。2
    子线程运行中。。。3
    子线程运行中。。。4
    main运行中。。。0
    子线程运行中。。。5
    子线程运行中。。。6
    子线程中断标志=true
    main运行中。。。1
    main运行中。。。2
    main运行中。。。3
    main运行中。。。4
    main运行中。。。5
    main运行中。。。6
    main运行中。。。7
    

    结论:

    1. 调用了另一个线程的interrupt方法后,会将它的中断标志位设置为false(没有抛出InterruptedException 的情况下);

    2. 被打断的线程除了标志位发生变化,没有任何改变。若没有其他操作,将会顺利执行完毕线程中的代码。

    2.打断阻塞状态的线程

    package com.demo;
    
    public class InterruputDemo {
    
        public static void main(String[] args) throws InterruptedException {
            demo2();
        }
    
        /**
         *打断线程的睡眠状态
         */
        public static void demo2() throws InterruptedException {
    
            Thread t = new Thread(() -> {
                while (!Thread.currentThread().isInterrupted()) {
                    try {
                        System.out.println("子线程运行中。。。");
                        //睡眠30秒
                        Thread.sleep(30000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        //当另一个线程(main线程)调用了本线程的interrupt方法后,若本线程正在sleep则会抛出InterruptedException异常,否则啥也不会发生;
                        //只有声明了InterruptedException异常的方法才会抛出这个异常;
                        //InterruptedException被抛出后,我们检查当前线程的阻塞状态,发现是false
                        boolean interrupted1 = Thread.currentThread().isInterrupted();//false
                        System.out.println("子线程的中断状态1=" + interrupted1);
                        Thread.currentThread().interrupt();
                        boolean interrupted2 = Thread.currentThread().isInterrupted();//true
                        System.out.println("子线程的中断状态2=" + interrupted2);
                    }
                }
            });
            t.start();
    
            int count = 0;
            while (true) {
                //睡眠1秒,等待子线程进入睡眠
                Thread.sleep(1000);
                t.interrupt();
                System.out.println("main运行中。。。" + count++);
            }
        }
    }
    

    运行结果:

    子线程运行中。。。
    main运行中。。。0
    子线程的中断状态1=false
    子线程的中断状态2=true
    java.lang.InterruptedException: sleep interrupted
    	at java.lang.Thread.sleep(Native Method)
    	at com.demo.InterruputDemo.lambda$demo2$0(InterruputDemo.java:19)
    	at java.lang.Thread.run(Thread.java:748)
    main运行中。。。1
    main运行中。。。2
    main运行中。。。3
    main运行中。。。4
    

    结论:

    1. 打断阻塞状态sleep中的线程,sleep方法会抛出InterruptedException异常;
    2. 抛出InterruptedException异常时,线程的中断标志会重新设置为false;
    3. 要想通过判断中断标志退出线程循环,需要在catch中再调用一次interrupt将中断标志设置为true。这时线程并不在阻塞状态,不会抛出异常。

    总结:

    1. 中断一个线程只是为了引起该线程的注意,被中断线程可以决定如何应对中断。
    2. Thread.interrupt()方法不会中断一个正在运行的线程。
    3. 如果线程在调用 Object 类的 wait()、wait(long) 或 wait(long, int) 方法,或者该Thread类的 join()、join(long)、join(long, int)、sleep(long) 或 sleep(long, int) 方法过程中受阻,则其中断状态将被清除,它还将收到一个InterruptedException异常。这个时候,我们可以通过捕获InterruptedException异常来终止线程的执行,具体可以通过return等退出或改变共享变量的值使其退出。
    4. synchronized在获锁的过程中是不能被中断的,意思是说如果产生了死锁,则不可能被中断(请参考后面的测试例子)。与synchronized功能相似的reentrantLock.lock()方法也是一样,它也不可中断的,即如果发生死锁,那么reentrantLock.lock()方法无法终止,如果调用时被阻塞,则它一直阻塞到它获取到锁为止。但是如果调用带超时的tryLock方法reentrantLock.tryLock(long timeout, TimeUnit unit),那么如果线程在等待时被中断,将抛出一个InterruptedException异常,这是一个非常有用的特性,因为它允许程序打破死锁。你也可以调用reentrantLock.lockInterruptibly()方法,它就相当于一个超时设为无限的tryLock方法。
    展开全文
  • 线程interrupt方法 线程类void interrupt() (Thread Class void interrupt()) This method is available in package java.lang.Thread.interrupt(). 软件包java.lang.Thread.interrupt()中提供了此方法。 This ...
  • 当线程呈wait()状态时,调用线程对象的interrupt方法会出现InterruptedException异常。二.案例:1)代码:package org.zhq.test; import java.util.ArrayList; import java.util.List; /** * @author 作者 hq....
  • 线程的interrupt方法 interrupt方法打断被sleep、wait、join方法阻塞的线程之后,会把线程的打断标记设置成true后重新设置成false。 interrupt方法打断正在运行的线程的时候,正在运行的线程会把打断标记设置成true...
  • 最近在学习Java多线程相关的知识点,其中关于线程停止的方法网上也有不少大牛给出了详细的解答,而我这边就其中Interrupt方法的注意点给自己提个醒。  首先还是大概的罗列下停止线程的方法:  1、使用stop()方法...
  •  下面是interrupt方法的文档的一部分: 1 * <p> If this thread is blocked in an invocation of the {@link 2 * Object#wait() wait()}, {@link Object#wait(long) wait(long)}, or {@link ...
  • 在Java中调用interrupt方法可以中断进程。与之相关的方法有 isInterrupted():返回一个boolean值,用于判断当前现成的打断状态。此方法不会重置打断标记。 interrupted():返回一个boolean值,用于判断当前现成的...
  • 使用interrupt方法中断线程

    千次阅读 2017-09-03 23:54:54
    Thread类的interrupt方法是用来中断一个线程的。
  • 如果想要线程达到死亡... interrupt方法 线程阻塞:抛出InterruptException异常,捕获异常后break跳出循环 线程未阻塞:采用isInterrupted判断线程是否中断 下面说一下如何正确使用interrupt方法中断线程 线程...
  • 线程interrupt方法: interrupt方法是用来停止线程的,但是他的使用效果并不像for+break那样,马上就停止循环。 调用interrupt()其实仅仅是在当前线程中打了一个停止标记,并没有真正的停止线程。 在下面的例子...
  • C#Thread的Interrupt方法

    千次阅读 2016-06-02 15:10:35
    Interrupt方法,只可以中断处于WaitSleepJoin状态的线程,当线程不为WaitSleepJoin时,线程将恢复执行。 调用Interrupt方法会产生ThreadInterruptException异常 class Program { static void Main(string[] ...
  • Java Thread的interrupt方法详解

    千次阅读 2018-01-25 15:06:02
    Java Thread的interrupt方法详解 一、概述 interrupt方法的目的是给线程发出中断信号,但是不保证线程真的会中断 中断一个线程只是为了引起该线程的注意,被中断线程可以决定如何应对中断。 Thread.interrupt...
  • java线程的interrupt方法

    2017-03-30 11:38:00
    java现成的interrupt方法比较容易误导新手,它其实是不会中断(停止)当前的线程,只是标志一下当前线程的某个状态值(中断标志位),并且这个状态为只对阻塞方法(比如说: Thread.sleep(),Thread.wait()或者I/O等...
  • java中Thread的Interrupt方法 TestInterrupt.java import java.util.*; /* 测试Interrupt中断方法 在线程睡眠时进行中断,会出现异常InterruptedException */ public class TestInterrupt { public ...
  • interrupt方法的引出 interrupt()不能中断在运行中的线程,它只能改变中断状态而已。 public class InterruptionInJava implements Runnable{ public static void main(String[] args) throws ...
  • 当其他线程通过调用当前线程的interrupt方法,表示向当前线程打个招呼,告诉他可以中断线程的执行了,至于什么时候中断,取决于当前线程自己。 线程通过检查资深是否被中断来进行相应,可以通过isInterrupted()来...
  • 文章目录用户线程和守护线程的区别interrupt方法、interrupted方法和isInterrupted方法区别isAlive方法优雅结束正在执行的线程 Java线程可以分为两类:用户线程和守护线程。 (1)通过线程对象.setDaemon(false)设置...
  • sleep和interrupt方法测试。提供了一种打断子线程的方式,不是最优方法。最优方法是在run函数里设置flag。还有一种stop()方法 ,直接杀死线程,不能再启动,多数情况下废弃。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,687
精华内容 1,474
关键字:

interrupt方法