精华内容
下载资源
问答
  • 2021-03-13 23:27:40

    根据线程名获取线程及停止进程

    线程的命名与获取名称方法

    设置名称可以使用Thread类的如下方法:

    *构造方法:public Thread (Runnable Target,String name)

    *设置名字:public final void setName(String name)

    获取线程名城:

    *当前运行的线程名称:Thread.currentThread().getName()

    *取得名字:public final String getName()

    创建运行线程

    public class MyThread extends Thread{

    @Override

    public void run() {

    try {

    sleep(Constants.OPERATION_AMOUNT_THREAD_TIME);

    /**

    逻辑代码

    */

    } catch (InterruptedException e) {

    Logger.info("线程:" + Thread.currentThread().getName()+"结束.");

    System.out.println(e.getMessage());

    }

    }

    }

    MyThread oat= newMyThread ();

    oat.setName("110");

    System.out.println("创建线程"+oat.getName());

    oat.start();

    根据线程名获取线程

    获取所有线程

    public class Main extends Thread {

    public static void main(String[] args) {

    Main t1 = new Main();

    t1.setName("thread1");

    t1.start();

    ThreadGroup currentGroup =

    Thread.currentThread().getThreadGroup();

    int noThreads = currentGroup.activeCount();

    Thread[] lstThreads = new Thread[noThreads];

    currentGroup.enumerate(lstThreads);

    for (int i = 0; i < noThreads; i++)

    System.out.println("线程号:" + i + " = " + lstThreads[i].getName());

    }

    }

    以上代码运行输出结果为:

    线程号:0=main

    线程号:1=thread1

    对对应的线程进行interrupt() (安全结束sleep中的进程的方式)

    对sleep中的线程进行interrupt()会抛异常 走catch方法 run方法正常结束 安全的停止线程。

    可根据自己的业务进程设计停止线程的方式 ,不建议使用stop方法 ,因为存在数据的一致性问题,并且stop方法已经呗java过期了。

    停止进程的方式详见http://blog..net/weixin_36795183/article/details/79227759

    //杀线程

    public static boolean killThreadByName(String name) {

    ThreadGroup currentGroup = Thread.currentThread().getThreadGroup();

    int noThreads = currentGroup.activeCount();

    Thread[] lstThreads = new Thread[noThreads];

    currentGroup.enumerate(lstThreads);

    Logger.info("现有线程数" + noThreads);

    for (int i = 0; i < noThreads; i++) {

    String nm = lstThreads[i].getName();

    Logger.info("线程号:" + i + " = " + nm);

    if (nm.equals(name)) {

    lstThreads[i].interrupt();

    return true;

    }

    }

    return false;

    }

    更多相关内容
  • 一、暂停或停止线程的理论 在Java编程中,要暂停或停止当前正在运行的线程,有几种方法。对于把线程转入睡眠Sleep状态,使用Thread.sleep()是最正确的方式。或许有人会问,为什么不使用等待wait()或通知notify()?要...
  • C#停止线程的方法

    2020-09-03 10:24:11
    主要介绍了C#停止线程的方法,实例分析了C#正确停止线程的实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • 【Java多线程】停止线程

    万次阅读 2021-10-03 22:37:21
    1. 停止线程的方法 2. 判断线程是否是停止状态 3. 能停止的线程——异常法 4. 在沉睡中停止 5. 能停止的线程——暴力停止 6. 方法stop()与java,lang.ThreadDeath异常 7. 使用return停止线程 1. 停止线程的...

    目录

    1. 停止线程的方法

    2. 判断线程是否是停止状态

    3. 能停止的线程——异常法

    4. 在沉睡中停止

    5. 能停止的线程——暴力停止

    6. 方法stop()与java,lang.ThreadDeath异常

    7. 使用return停止线程


    1. 停止线程的方法

    在Java中有以下3种方法可以终止正在进行的线程:

    1)使用退出标志,使线程正常退出,也就是当run方法完成后线程终止。

    2)使用stop方法强行终止线程,但是不推荐使用这个方法,因为stop和suspend及resume一样,都是作废过期的方法,使用它们可能产生不可预料的结果。

    3)使用interrupt方法中断线程。

    停止一个线程意味着在线程处理完任务之前停掉正在做的操作,也就是放弃当前的操作。虽然这看起来非常简单,但是必须做好防范措施,以便达到预期的效果。停止一个线程可以使用Thread.stop()方法,但最好不用它。虽然它确实可以停止一个正在运行的线程,但是这个方法是不安全的(unsafe),而且是已被弃用作废的(deprecated), 在将来的Java版本中,这个方法将不可用或不被支持。

    大多数停止一个线程的操作使用Thread.interrupt()方法,尽管方法的名称是“停止,中止”的意思,但这个方法不会终止一个正在运行的线程,还需要加入一个判断才可以完成线程的停止。

    2. 判断线程是否是停止状态

    Thread.java类提供了两种方法。

    1)this.interrupted():测试当前线程是否已经中断。

    测试当前线程是否中断。 该方法可以清除线程的中断状态,执行后具有将状态标志置消除为false的功能 。 换句话说,如果这个方法被连续调用两次,那么第二个调用将返回false(除非当前线程再次中断,在第一个调用已经清除其中断状态之后,在第二个调用之前已经检查过)。

    忽略线程中断,因为线程在中断时不存在将被该方法返回false所反映。

    // 源代码,声明
    public void interrupt();

    2)this.isInterrupted():测试线程是否已经中断。

    测试这个线程是否被中断。 线程的中断状态不受此方法的影响,但不清除状态标志。

    忽略线程中断,因为线程在中断时不存在将被该方法返回false所反映。

    // 源代码,声明
    public static boolean interrupted();
    
    public boolean isInterrupted();

    3. 能停止的线程——异常法

    下面是一个例子:

    自定义线程:

    public class MyThread extends Thread {
        @Override
        public void run() {
            super.run();
            for (int i = 0; i < 500000; i++) {
                if (this.interrupted()) {
                    System.out.println("已经是停止状态了!我要退出了!");
                    break;
                }
                System.out.println("i=" + (i + 1));
            }
            System.out.println("我被输出,如果此代码是for又继续运行,线程并未停止!");
        }
    }

    运行代码:

    public class Run {
        public static void main(String[] args) {
            try {
                MyThread thread = new MyThread();
                thread.start();
                Thread.sleep(1000);
                thread.interrupt();
            } catch (InterruptedException e) {
                System.out.println("main catch");
                e.printStackTrace();
            }
            System.out.println("end!");
        }
    }
    

    上面的示例虽然停止了线程,但如果for语句下面还有语句,还是会继续运行的。

    将上述代码改为:

    public class MyThread extends Thread {
        @Override
        public void run() {
            super.run();
            try {
                for (int i = 0; i < 500000; i++) {
                    if (this.interrupted()) {
                        System.out.println("已经是停止状态了!我要退出了!");
                        throw new InterruptedException();
                    }
                    System.out.println("i=" + (i + 1));
                }
                System.out.println("我在for下面");
            } catch (InterruptedException e) {
                System.out.println("进MyThread.java类run方法种的catch了!");
                e.printStackTrace();
            }
        }
    }

    输出结果:

    4. 在沉睡中停止

    如果线程在sleep()状态下停止线程,会是什么效果呢?

    下面通过一个示例来说明:

    public class MyThread extends Thread {
        @Override
        public void run() {
            super.run();
            try {
                System.out.println("run begin");
                Thread.sleep(200000);
                System.out.println("run end");
            } catch (InterruptedException e) {
                System.out.println("在沉睡中被停止!进入catch!"+this.isInterrupted());
                e.printStackTrace();
            }
        }
    }

    运行代码:

    public class Run {
        public static void main(String[] args) {
            try {
                MyThread thread = new MyThread();
                thread.start();
                Thread.sleep(200);
                thread.interrupt();
            } catch (InterruptedException e) {
                System.out.println("main catch");
                e.printStackTrace();
            }
            System.out.println("end!");
        }
    }
    

    执行结果:

     从打印结果来看,如果在sleep状态下停止某一线程,会进入catch语句,并且清楚停止状态值,使之变成false。

    【注】:如果先将线程停止,然后进入sleep,会发生什么呢?如下示例:

    public class MyThread extends Thread {
        @Override
        public void run() {
            super.run();
            try {
                for(int i=0;i<100000;i++){
                    System.out.println("i="+(i+1));
                }
                System.out.println("run begin");
                Thread.sleep(200000);
                System.out.println("run end");
            } catch (InterruptedException e) {
                System.out.println("先停止,再遇到了sleep!进入catch!");
                e.printStackTrace();
            }
        }
    }
    public class Run {
        public static void main(String[] args) {
            MyThread thread = new MyThread();
            thread.start();
            thread.interrupt();
            System.out.println("end!");
        }
    }
    

    5. 能停止的线程——暴力停止

    使用stop()方法停止线程则是非常暴力的。

    public class MyThread extends Thread {
        private int i = 0;
    
        @Override
        public void run() {
            try {
                while (true) {
                    i++;
                    System.out.println("i=" + i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    public class Run {
        public static void main(String[] args) {
            try {
                MyThread thread = new MyThread();
                thread.start();
                Thread.sleep(8000);
                thread.stop();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    

    运行结果:

    6. 方法stop()与java,lang.ThreadDeath异常

    调用stop()方法时会抛出java.lang.ThreadDeath异常,但在通常的情况下,此异常不需要显示地捕捉。

    方法stop()已经被作废,因为如果强制让线程停止则有可能使一些清理性的工作得不到完成。另一个情况就是对锁定的对象进行了”解锁“,导致数据得不到同步的处理,出现数据不一致的问题。

    7. 使用return停止线程

    将方法interrupt()和return结合使用也能实现停止线程的效果。

    public class MyThread extends Thread {
        @Override
        public void run() {
            while (true) {
                if (this.isInterrupted()) {
                    System.out.println("停止了!");
                    return;
                }
                System.out.println("timer=" + System.currentTimeMillis());
            }
        }
    }
    public class Run {
        public static void main(String[] args)  throws InterruptedException {
            MyThread t=new MyThread();
            t.start();
            Thread.sleep(1000);
            t.interrupt();
        }
    }
    

    执行结果:

     不过还是建议使用"抛异常"的方法来实现线程的停止,因为在catch块中还可以将异常向上抛,使线程停止的事件得以传播。

    展开全文
  • Java如何正确停止线程(三种场景)

    千次阅读 2020-11-01 15:53:35
    本文将讲解Java中三种场景下如何正确的停止线程,分别是普通情况、堵塞状态、循环中堵塞状态,三种情况下如何正确的停止线程。线程在三种场景下的停止方式,都是通过`interrupt()`方法来停止的,但特殊的是停止循环...

    简介

    俗话说:上山容易下山难。知道如何启动线程,那么到底如何停止线程呢?本文将讲解Java中三种场景下如何正确的停止线程,分别是普通情况、堵塞状态、循环中堵塞状态,三种情况下如何正确的停止线程。

    场景一:普通场景下如何停止线程

    如何停止线程:

    我们只能调用线程的interrupt()方法通知系统停止线程,并不能强制停止线程。线程能否停止,何时停止,取决于系统。

    注意

    Java中线程的stop()suspend()resume()三个方法都已经被弃用,所以不再使用stop()方法停止线程。

    1.代码演示

    代码逻辑描述:

    创建一个子线程,子线程汇总循环打印数字。然后我们在其他线程中,调用子线程的interrupt()方法停止线程,观察停止前后的控制台输出情况,理解上述线程停止的含义。

    public class StopNormalThread {
    
    	public static void main(String[] args) throws InterruptedException {
    		// 最好的停止线程方式:通过interrupt通知线程停止线程;而且只能通知,并不能强制让其停止。
    		testInterruptThread();
    
    	}
    
    	/**
    	 * 线程只能通知停止,不能强制立刻停止测试。
    	 */
    	private static void testInterruptThread() throws InterruptedException {
    		Thread thread = new Thread(new Runnable() {
    			public void run() {
    				for (int i = 0; i <= 1000000; i++) {
    					// 判断如果线程没有被中断,则继续输出
    					if (!Thread.currentThread().isInterrupted()) {
    						System.out.println("当前输出位置:" + i);
    					}
    				}
    			}
    		});
    		thread.start();
    		System.out.println("子线程已经启动");
    		//主线程休眠,让子线程跑一会儿,然后让子线程停止
    		Thread.sleep(1000);
    		System.out.println("主线程休眠结束,开始停止子线程");
    		// 终止后,发现for循环还会继续输出内容,少许时间后才停止。说明我们无法控制线程立刻停止。
    		thread.interrupt();
    		System.out.println("子线程已被停止");
    	}
    
    }
    

    程序输出节选:

    子线程已经启动
    当前输出位置:0
    当前输出位置:1
    当前输出位置:2
    略……
    当前输出位置:430290
    当前输出位置:430291
    当前输出位置:430292
    主线程休眠结束,开始停止子线程
    当前输出位置:430293
    当前输出位置:430294
    当前输出位置:430295
    当前输出位置:430296
    当前输出位置:430297
    当前输出位置:430298
    当前输出位置:430299
    当前输出位置:430300
    当前输出位置:430301
    当前输出位置:430302
    当前输出位置:430303
    子线程已被停止
    
    Process finished with exit code 0
    
    

    运行结果解释:

    我们可以看出,子线程创建并启动后,开始输出数字,当主线程中调用thread.interrupt()方法时,即通知系统要停止子线程的运行了,此时控制台中还是会有数字继续输出,这就表明:我们只能通过thread.interrupt()方法通知系统停止子线程,但子线程可能不会立即停止,可能还会继续运行一段时间才会停止。

    场景一:普通场景下通过调用thread.interrupt()方法停止线程

    场景二:堵塞状态下如何停止线程

    什么是堵塞状态:阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态,即还没有真正运行Synchronized修饰的代码时的状态。BLOCKED或WAITING或TIME_WAITING这三种统称为堵塞状态

    关于线程状态的内容,如不有不明白的地方,可参考:《Java线程状态完全解析教程》

    代码逻辑描述:

    在主线程中创建一个子线程并运行,然后休眠两秒后,让子线程停止。

    在子线程中,循环打印数字,然后让子线程休眠1秒(此时子线程进入阻塞状态),然后子线程会被停止。

    public class StopBlockThread {
    
    	public static void main(String[] args) throws InterruptedException {
    		testBlockingInterruptThread();
    
    	}
    
    	/**
    	 * 中止堵塞状态的线程示例
    	 */
    	private static void testBlockingInterruptThread() {
    		try {
    			Thread thread = new Thread(new Runnable() {
    				public void run() {
    					for (int i = 0; i <= 1000000; i++) {
    						// 判断如果线程没有被中断,则继续输出
    						if (!Thread.currentThread().isInterrupted()) {
    							System.out.println("当前输出位置:" + i);
    						}
    					}
    					try {
    						// 模拟线程堵塞
    						System.out.println("--1--模拟线程堵塞中");
    						Thread.sleep(1000);
    						System.out.println("--2--此行不会被打印,即线程以被停止");
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				}
    			});
    			thread.start();
    			System.out.println("让子线程运行两秒,然后再通知其停止");
    			Thread.sleep(2000);
    			/*让子线程for循环在没有循环结束时,接收到停止信号,此时子线程停止,并执行sleep(模拟阻塞状态)时,
    			会抛出sleep interrupted中断异常,表示堵塞状态也被中断了,即堵塞状态的线程成功被终止了 */
    			thread.interrupt();
    			System.out.println("通知停止线程");
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    
    }
    

    程序输出节选:

    让子线程运行两秒,然后再通知其停止
    当前输出位置:0
    当前输出位置:1
    当前输出位置:2
    略……
    当前输出位置:897419
    当前输出位置:897420
    当前输出位置:897421
    通知停止线程
    --1--模拟线程堵塞中
    java.lang.InterruptedException: sleep interrupted
    	at java.lang.Thread.sleep(Native Method)
    	at thread.stop.StopBlockThread$1.run(StopBlockThread.java:31)
    	at java.lang.Thread.run(Thread.java:748)
    
    Process finished with exit code 0
    

    运行结果解释:

    分析下子线程的运行流程,子线程启动后循环打印数字,打印语句有一个判断条件!Thread.currentThread().isInterrupted(),意思是只要不被中断才打印,若中断了,就不再打印,转而往下执行Thread.sleep(1000)语句,进入堵塞状态。

    此时主线程调用了thread.interrupt(),系统尝试中断子线程,发现子线程在阻塞状态中,所以会抛出异常sleep interrupted,然后我们发现控制台输出Process finished with exit code 0,表示线程被正常停止了。

    场景二:阻塞状态下也可以通过thread.interrupt()停止线程

    场景三:循环中堵塞状态下如何停止线程

    代码逻辑描述:

    主线程中创建一个子线程并运行,两秒钟后,停止子线程。

    子线程run()方法中,写一个循环打印数字逻辑,并在每次循环中,都调用一次Thread.sleep(20),目的是让每次循环都进入堵塞状态。此时要想正常停止线程,必须要在循环外部增加try-catch语句,即当阻塞被停止时,会抛出异常,此时即可终止循环,停止线程

    public class StopLoopBlockThread {
    
    	public static void main(String[] args) {
    		testLoopBlockStopThread();
    	}
    
    	/**
    	 * 循环中存在堵塞的线程停止示例(关键是将循环放到try-catch内部才生效)
    	 */
    	private static void testLoopBlockStopThread() {
    
    		Thread thread = new Thread(new Runnable() {
    			public void run() {
    				try {
    					/* 此处不需要判断线程是否已经被中断了,因为如果在循环中的休眠过程中(堵塞时),
    					 收到interrupt信号,则会立刻抛出停止休眠异常*/
    					for (int i = 0; i < 1000; i++) {
    						System.out.println("当前输出位置:" + i);
    						// 模拟每次循环都堵塞
    						Thread.sleep(20);
    					}
    				} catch (InterruptedException e) {
    					/* try-catch一定放在循环外部,否则线程将不会停止。因为中断异常在循环中被捕获,
    					但循环并没有满足循环停止条件,所以知道循环运行结束,才会停止。即时在循环终止条件中,
    					添加`!Thread.currentThread().isInterrupted()`判断,循环也不会停止,因为线程的sleep()方法,
    					一旦抛出被中断异常后,其isInterrupted标记也会被清除,所以也无法立即停止线程*/
    					e.printStackTrace();
    				}
    			}
    		});
    
    		thread.start();
    		try {
    			Thread.sleep(2000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		thread.interrupt();
    	}
    
    }
    

    程序输出节选:

    当前输出位置:0
    当前输出位置:1
    当前输出位置:2
    当前输出位置:3
    略...
    当前输出位置:95
    当前输出位置:96
    java.lang.InterruptedException: sleep interrupted
    	at java.lang.Thread.sleep(Native Method)
    	at thread.stop.StopLoopBlockThread$1.run(StopLoopBlockThread.java:27)
    	at java.lang.Thread.run(Thread.java:748)
    	
    Process finished with exit code 0
    

    运行结果解释:

    本例最关键地方在于如果仅仅把try-catch语句包裹子线程中的在Thread.sleep(20)上,一旦接收到终止信号,程序开始终止sleep()方法的阻塞状态会抛出异常,此时异常将在循环体内被捕获,循环并不能终止,子线程还是会继续运行,一直运行到for循环结束才能正常停止。这样就不符合我们预期,我们想让程序尽快的做出停止操作,如果程序没有终止,则会造成很多不可挽回的结果。

    场景三:循环中堵塞状态下正确的停止线程,也可以通过thread.interrupt()停止线程,但需要在子线程的循环外部增加try-catch代码块,捕获到中止堵塞状态异常时,也能停止线程。

    总结

    本文介绍了线程在三种场景下的停止方式,都是通过interrupt()方法来停止的,但特殊的是停止循环中的阻塞线程时,需要在循环外部增加try-catch代码块,捕获到中止堵塞状态异常时停止线程。希望这篇文章可以让你掌握如何在多线程编程中,正确的停止线程。喜欢本文请收藏、点赞、关注。

    参考资料补充:
    关于多线程、synchronized关键字wait()notify()方法的系列教程,请参考以下文章:

    《Java线程状态完全解析教程》

    《Java中synchronized实现类锁的两种方式及原理解析》

    《Java中synchronized实现对象锁的两种方式及原理解析》

    《Java多线程wait()和notify()系列方法使用教程》

    《Java多线程中notifyAll()方法使用教程》

    《Java两个线程交替打印奇偶数(两种方法对比)》

    《Java中Synchronized的可重入性和不可中断性的分析和代码验证》

    《Java多线程访问Synchronized同步方法的八种使用场景》

    《Java官方文档创建线程的两种方式及优点和缺点分析》

    《Java中线程安全和线程不安全解析和示例》

    展开全文
  • Java停止线程的3种方式

    千次阅读 2022-03-04 11:12:43
    在Java中有以下3种方式终止正在运行的线程: 使用退出标志,使线程正常退出; 使用stop()方法强行终止线程,不推荐使用该方法,JDK已声明弃用; 使用interrupt方法中断线程。 使用标志位 在 run() 方法执行完毕后...

    在Java中有以下3种方式终止正在运行的线程:

    • 使用退出标志,使线程正常退出;
    • 使用stop()方法强行终止线程,不推荐使用该方法,JDK已声明弃用;
    • 使用interrupt方法中断线程。

    使用标志位

    在 run() 方法执行完毕后,该线程就终止了。但是在某些特殊的情况下,run() 方法会被一直执行;比如在服务端程序中可能会使用 while(true) { … } 这样的循环结构来不断的接收来自客户端的请求。此时就可以用修改标志位的方式来结束 run() 方法。

    public class ServerThread extends Thread {
        //volatile修饰符用来保证其它线程读取的总是该变量的最新的值
        public volatile boolean exit = false; 
    
        @Override
        public void run() {
            ServerSocket serverSocket = new ServerSocket(8080);
            while(!exit){
                serverSocket.accept(); //阻塞等待客户端消息
                ...
            }
        }
        
        public static void main(String[] args) {
            ServerThread t = new ServerThread();
            t.start();
            ...
            t.exit = true; //修改标志位,退出线程
        }
    }
    

    使用stop()

    通过查看 JDK 的 API,我们会看到 java.lang.Thread 类型提供了一系列的方法如 start()、stop()、resume()、suspend()、destory()等方法来管理线程。但是除了 start() 之外,其它几个方法都被声名为已过时(deprecated)。

    虽然 stop() 方法确实可以停止一个正在运行的线程,但是这个方法是不安全的,而且该方法已被弃用,最好不要使用它。

    为什么弃用stop:

    • 调用 stop() 方法会立刻停止 run() 方法中剩余的全部工作,包括在 catch 或 finally 语句中的,并抛出ThreadDeath异常(通常情况下此异常不需要显示的捕获),因此可能会导致一些清理性的工作的得不到完成,如文件,数据库等的关闭。
    • 调用 stop() 方法会立即释放该线程所持有的所有的锁,导致数据得不到同步,出现数据不一致的问题。

    例如,存在一个对象 u 持有 ID 和 NAME 两个字段,假如写入线程在写对象的过程中,只完成了对 ID 的赋值,但没来得及为 NAME 赋值,就被 stop() 导致锁被释放,那么当读取线程得到锁之后再去读取对象 u 的 ID 和 Name 时,就会出现数据不一致的问题,如下图:

    在这里插入图片描述

    使用 interrupt()

    现在我们知道了使用 stop() 方式停止线程是非常不安全的方式,那么我们应该使用什么方法来停止线程呢?答案就是使用 interrupt() 方法来中断线程。

    需要明确的一点的是:interrupt() 方法并不像在 for 循环语句中使用 break 语句那样干脆,马上就停止循环。调用 interrupt() 方法仅仅是在当前线程中打一个停止的标记,并不是真的停止线程。

    也就是说,线程中断并不会立即终止线程,而是通知目标线程,有人希望你终止。至于目标线程收到通知后会如何处理,则完全由目标线程自行决定。这一点很重要,如果中断后,线程立即无条件退出,那么我们又会遇到 stop() 方法的老问题。

    事实上,如果一个线程不能被 interrupt,那么 stop 方法也不会起作用。

    我们来看一个使用 interrupt() 的例子:

    public class InterruptThread1 extends Thread{
    
        public static void main(String[] args) {
            try {
                InterruptThread1 t = new InterruptThread1();
                t.start();
                Thread.sleep(200);
                t.interrupt();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        @Override
        public void run() {
            super.run();
            for(int i = 0; i <= 200000; i++) {
                System.out.println("i=" + i);
            }
        } 
    }
    

    输出:
    在这里插入图片描述
    从输出的结果我们会发现 interrupt 方法并没有停止线程 t 中的处理逻辑,也就是说即使 t 线程被设置为了中断状态,但是这个中断并不会起作用,那么该如何停止线程呢?

    这就需要使用到另外两个与线程中断有关的方法了:

    public boolean Thread.isInterrupted() //判断是否被中断
    public static boolean Thread.interrupted() //判断是否被中断,并清除当前中断状态
    

    这两个方法使得当前线程能够感知到是否被中断了(通过检查标志位)。

    所以如果希望线程 t 在中断后停止,就必须先判断是否被中断,并为它增加相应的中断处理代码:

    @Override
    public void run() {
        super.run();
        for(int i = 0; i <= 200000; i++) {
            //判断是否被中断
            if(Thread.currentThread().isInterrupted()){
                //处理中断逻辑
                break;
            }
            System.out.println("i=" + i);
        }
    }
    

    输出结果,for 循环在执行完成前就提前结束了:
    在这里插入图片描述
    在上面这段代码中,我们增加了 Thread.isInterrupted() 来判断当前线程是否被中断了,如果是,则退出 for 循环,结束线程。

    这种方式看起来与之前介绍的“使用标志位终止线程”非常类似,但是在遇到 sleep() 或者 wait() 这样的操作,我们只能通过中断来处理了。

    public static native void sleep(long millis) throws InterruptedException
    

    Thread.sleep() 方法会抛出一个 InterruptedException 异常,当线程被 sleep() 休眠时,如果被中断,这会就抛出这个异常。
    (注意:Thread.sleep() 方法由于中断而抛出的异常,是会清除中断标记的。)

    展开全文
  • Java停止线程的三种方式

    千次阅读 2021-07-25 17:15:01
    Java停止线程的三种方式 停止线程的核心:个人认为是让线程结束执行run方法,即线程退出 围绕该核心,可以使用以下几种方式停止线程 通过标记位停止 **(推荐)**通过interrupted()设置清除标记方式停止 通过stop...
  • 在使用线程时,最麻烦的就是线程的同步控制,如... 本人经过试验和总结,整理出可以安全的进行暂停、继续、停止线程执行的一个线程类,能非常方便的对线程进行控制。 附件里是源码和Sample程序,并有详细的使用说明。
  • ======创建线程的方式====== 继承Thead类,重写run()方法 ...======停止线程的方式====== 使用stop()方法 使用suspend()和resume()方法 配合volatile 使用interrupt()方法 什么都不做,让线程自然结束
  • 使用ExecutorService来停止线程服务

    万次阅读 2020-04-08 09:57:04
    使用ExecutorService来停止线程服务 之前的文章中我们提到了ExecutorService可以使用shutdown和shutdownNow来关闭。 这两种关闭的区别在于各自的安全性和响应性。shutdownNow强行关闭速度更快,但是风险也更大,因为...
  • Java停止线程的四种方法

    千次阅读 2019-06-09 13:26:34
    一、线程停止基础知识 interrupted(): 测试当前线程是否已经中断。该方法为静态方法,调用后会返回boolean值。不过调用之后会改变线程的状态,如果是中断状态调用的,调用之后会...stop(): 暴力停止线程。已弃用。...
  • 停止线程的几种简单方法

    千次阅读 2020-09-26 15:03:38
    停止线程最简单的方法是使用stop()方法暴力停止,但是这种方法在java中已经被画横线抛弃,是不再被采用的方法,原因有两,其一是因为stop()方法容易造成业务处理的不确定性,其二是因为stop()释放锁会给数据造成不...
  • 根据线程名获取线程及停止线程

    千次阅读 2020-12-18 09:49:51
    线程的命名与获取名称方法 设置名称可以使用Thread类的如下方法: *构造方法:public Thread (Runnable Target,String name) *设置名字:public final void setName(String name) 获取线程...
  • java线程池停止线程 停止线程 (Stopping a thread) As we know that there are no direct or shortcut ways to stop thread in Java. 众所周知,在Java中没有直接或快捷的方式来停止线程。 As we know thread in ...
  • 实现三个线程同时执行,且可以单独关闭和运行,通过进度条实现可视化演示。
  • 使用退出标识,使得线程正常退出,即当run方法完成后进程终止。 private int tickeys=10; private boolean flag=true; @Override public void run() { while (flag){ try { buyTickey(); } catch ...
  • Java如何停止线程

    千次阅读 2018-10-25 11:28:24
    启动一个线程或任务都是很简单,线程一般在任务结束后便会自行停止。但是有时我们希望能够在线程自行停止前能够停止它们,比如一些取消操作,或者是应用程序需要快速关闭。博主日前就遇到了这样的问题。 但是在...
  • 停止线程 欢迎使用Markdown编辑器写博客 本Markdown编辑器使用StackEdit修改而来,用它写博客,将会带来全新的体验哦: Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列...
  • 【多线程】——停止线程的三种方式

    万次阅读 热门讨论 2018-04-28 18:33:47
    前提 停止线程是在多线程开发时非常重要的方式,掌握线程的停止可以对线程的停止进行有效的处理。停止线程在Java中不像break那样干脆,而需要一些技巧性。停止线程的方式有三种,分别展示一下方式一使用退出标识,...
  • http://blog.csdn.net/ssssssue 停止线程 测试interrupt中断线程 测试interrupt中断线程 public class Demo { public static void main(String[] args) { StopRunnable stopRunnable = new Stop
  • 多线程的终止方法(停止线程

    千次阅读 2019-07-08 23:30:07
    停止线程是多线程中的一个重要技术点,本篇文章将对线程的停止操作进行详细讲解。 停止线程不能像for或while循环中使用break停止那样直接,而是需要一些技巧来终止。 如何判断线程已终止 Thread类中提供了两个...
  • C++11关于thead的应用,利用std::condition std::mutex提供如何中断,停止和继续功能,
  • 停止线程的三种方法

    千次阅读 2017-08-04 17:50:56
    在Java中有以下3种方法可以终止正在运行的线程: 1. 抛异常法; 2. 使用stop方法强行终止线程 3. 使用interrupt方法中断...使用抛异常法首先要判断该线程是否是停止状态,只有是停止状态才抛异常。 下面是具体
  • 让每一个子线程在开启之前设置一个守护线程,这样就可以在主线程结束之后,同时也能停止线程。 Button(myWindow, text='Apply', command=self.download_customers).place() def download_customers(self): ...
  • 线程的实现方式有如下三种 1)继承Thread类创建线程 重写run方法 2)实现Runnable接口创建线程 3)使用Callable和Future创建线程 重写call方法 通过继承Thread类来创建并启动多线程的一般步骤如下 1. 定义Thread类...
  • 本文实例讲述了C#实现终止正在执行的线程的实现方法,并针对一些容易出错的地方进行了深入分析,具体方法如下: ...当我们需要线程退出时,只要设置这个“停止”信号为true即可。   下面我们来看具体的操作步骤。
  • 在开发多线程程序时,经常由于需要重新执行任务从而取消(停止)工作线程。C++11目前并没有很好的取消线程执行的机制。那么我们应该如何实现取消线程呢? 说明 C++11使用<future>库进行线程间数据通讯,也...
  • Android中如何巧妙停止线程的方法

    万次阅读 2018-03-13 18:58:06
    而业务需求中又要允许用户在倒计时未结束时手动划掉消失,则此时需要停止倒计时线程。或者可能有时有多单依次叠加,此时最上面的一单消失时,也需要先停止上一单倒计时再自动开启下一单的倒计时。 如果是n...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 399,839
精华内容 159,935
关键字:

如何停止线程