精华内容
下载资源
问答
  • 如何优雅地停止一个线程

    千次阅读 2019-09-03 09:11:57
    Java 中 Thread 类有一个 stop() 方法,可以终止线程,不过这个方法会让线程直接终止,在执行的任务立即终止,未执行的任务无法反馈,所以 stop() 方法已经不建议使用。 既然 stop() 方法如此粗暴,不建议使用,...

    线程终止有两种情况:

    1、线程的任务执行完成

    2、线程在执行任务过程中发生异常

     

    这两者属于线程自行终止,如何让线程 A 把线程 B 终止呢?

    Java 中 Thread 类有一个 stop() 方法,可以终止线程,不过这个方法会让线程直接终止,在执行的任务立即终止,未执行的任务无法反馈,所以 stop() 方法已经不建议使用。

     

    既然 stop() 方法如此粗暴,不建议使用,我们如何优雅地结束线程呢?

    线程只有从 runnable 状态(可运行/运行状态) 才能进入terminated 状态(终止状态),如果线程处于 blocked、waiting、timed_waiting 状态(休眠状态),就需要通过 Thread 类的 interrupt()  方法,让线程从休眠状态进入 runnable 状态,从而结束线程。

     

    当线程进入 runnable 状态之后,通过设置一个标识位,线程在合适的时机,检查该标识位,发现符合终止条件,自动退出 run () 方法,线程终止。

     

    如我们模拟一个系统监控任务线程,代码如下

    package constxiong.concurrency.a007;
    
    /**
     * 模拟系统监控
     * @author ConstXiong
     */
    public class TestSystemMonitor {
    	
    	public static void main(String[] args) {
    		testSystemMonitor();//测试系统监控器
    	}
    	
    	/**
    	 * 测试系统监控器
    	 */
    	public static void testSystemMonitor() {
    		SystemMonitor sm = new SystemMonitor();
    		sm.start();
    		try {
    			//运行 10 秒后停止监控
    			Thread.sleep(10 * 1000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println("监控任务启动 10 秒后,停止...");
    		sm.stop();
    	}
    	
    }
    
    /**
     * 系统监控器
     * @author ConstXiong
     */
    class SystemMonitor {
    	
    	private Thread t;
    	
    	/**
    	 * 启动一个线程监控系统
    	 */
    	void start() {
    		t = new Thread(() -> {
    			while (!Thread.currentThread().isInterrupted()) {//判断当前线程是否被打断
    				System.out.println("正在监控系统...");
    				try {
    					Thread.sleep(3 * 1000L);//执行 3 秒
    					System.out.println("任务执行 3 秒");
    					System.out.println("监控的系统正常!");
    				} catch (InterruptedException e) {
    					System.out.println("任务执行被中断...");
    				}
    			}
    		});
    		t.start();
    	}
    
    	void stop() {
    		t.interrupt();
    	}
    }
    

    执行结果 

    正在监控系统...
    任务执行 3 秒
    监控的系统正常!
    正在监控系统...
    任务执行 3 秒
    监控的系统正常!
    正在监控系统...
    任务执行 3 秒
    监控的系统正常!
    正在监控系统...
    监控任务启动 10 秒后,停止...
    任务执行被中断...
    正在监控系统...
    任务执行 3 秒
    监控的系统正常!
    正在监控系统...
    .
    .
    .

     

    从代码和执行结果我们可以看出,系统监控器 start() 方法会创建一个线程执行监控系统的任务,每个任务查询系统情况需要 3 秒钟,在监控 10 秒钟后,主线程向监控器发出停止指令。

    但是结果却不是我们期待的,10 秒后并没有终止了监控器,任务还在执行

     

    原因在于,t.interrupt() 方法让处在休眠状态的语句 Thread.sleep(3 * 1000L); 抛出异常,同时被捕获,此时 JVM 的异常处理会清除线程的中断状态,导致任务一直在执行。

     

    处理办法是,在捕获异常后,继续重新设置中断状态,代码如下

    package constxiong.concurrency.a007;
    
    /**
     * 模拟系统监控
     * @author ConstXiong
     */
    public class TestSystemMonitor {
    	
    	public static void main(String[] args) {
    		testSystemMonitor();//测试系统监控器
    	}
    	
    	/**
    	 * 测试系统监控器
    	 */
    	public static void testSystemMonitor() {
    		SystemMonitor sm = new SystemMonitor();
    		sm.start();
    		try {
    			//运行 10 秒后停止监控
    			Thread.sleep(10 * 1000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println("监控任务启动 10 秒后,停止...");
    		sm.stop();
    	}
    	
    }
    
    /**
     * 系统监控器
     * @author ConstXiong
     */
    class SystemMonitor {
    	
    	private Thread t;
    	
    	/**
    	 * 启动一个线程监控系统
    	 */
    	void start() {
    		t = new Thread(() -> {
    			while (!Thread.currentThread().isInterrupted()) {//判断当前线程是否被打断
    				System.out.println("正在监控系统...");
    				try {
    					Thread.sleep(3 * 1000L);//执行 3 秒
    					System.out.println("任务执行 3 秒");
    					System.out.println("监控的系统正常!");
    				} catch (InterruptedException e) {
    					System.out.println("任务执行被中断...");
    					Thread.currentThread().interrupt();//重新设置线程为中断状态
    				}
    			}
    		});
    		t.start();
    	}
    
    	void stop() {
    		t.interrupt();
    	}
    }
    

    执行结果如预期

    正在监控系统...
    任务执行 3 秒
    监控的系统正常!
    正在监控系统...
    任务执行 3 秒
    监控的系统正常!
    正在监控系统...
    任务执行 3 秒
    监控的系统正常!
    正在监控系统...
    监控任务启动 10 秒后,停止...
    任务执行被中断...
    

     

    到这里还没有结束,我们用 Thread.sleep(3 * 1000L); 去模拟任务的执行,在实际情况中,一般是调用其他服务的代码,如果出现其他异常情况没有成功设置线程的中断状态,线程将一直执行下去,显然风险很高。所以,需要用一个线程终止的标识来代替 Thread.currentThread().isInterrupted()。

    修改代码如下

    package constxiong.concurrency.a007;
    
    /**
     * 模拟系统监控
     * @author ConstXiong
     */
    public class TestSystemMonitor {
    	
    	public static void main(String[] args) {
    		testSystemMonitor();//测试系统监控器
    	}
    	
    	/**
    	 * 测试系统监控器
    	 */
    	public static void testSystemMonitor() {
    		SystemMonitor sm = new SystemMonitor();
    		sm.start();
    		try {
    			//运行 10 秒后停止监控
    			Thread.sleep(10 * 1000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println("监控任务启动 10 秒后,停止...");
    		sm.stop();
    	}
    	
    }
    
    /**
     * 系统监控器
     * @author ConstXiong
     */
    class SystemMonitor {
    	
    	private Thread t;
    	
    	private boolean stop = false;
    	
    	/**
    	 * 启动一个线程监控系统
    	 */
    	void start() {
    		t = new Thread(() -> {
    			while (!stop) {//判断当前线程是否被打断
    				System.out.println("正在监控系统...");
    				try {
    					Thread.sleep(3 * 1000L);//执行 3 秒
    					System.out.println("任务执行 3 秒");
    					System.out.println("监控的系统正常!");
    				} catch (InterruptedException e) {
    					System.out.println("任务执行被中断...");
    					Thread.currentThread().interrupt();//重新设置线程为中断状态
    				}
    			}
    		});
    		t.start();
    	}
    
    	void stop() {
    		stop = true;
    		t.interrupt();
    	}
    }
    

    执行结果

    正在监控系统...
    任务执行 3 秒
    监控的系统正常!
    正在监控系统...
    任务执行 3 秒
    监控的系统正常!
    正在监控系统...
    任务执行 3 秒
    监控的系统正常!
    正在监控系统...
    监控任务启动 10 秒后,停止...
    任务执行被中断...
    

    到这里基本算是优雅地让线程终止了。

     

    使用 volatile 修饰 stop 变量有必要吗?作用是什么?

    线程只能通过 runnable 状态到 terminated 状态,那线程状态是如何变化的呢?

    我们后续继续实践。

     


    【Java面试题与答案】整理推荐

     

    展开全文
  • Java停止一个线程的几种方法

    千次阅读 2015-11-07 22:26:11
    Java中停止一个线程有三种方法,分别是stop,interrupt和设置标志位,我们依次来看一下这三种方法。 首先不推荐使用stop方法,原因有两点: 1、原则上只要一调用thread.stop()方法线程就会立即停止,并抛出...

    Java中停止一个线程有三种方法,分别是stop,interrupt和设置标志位,我们依次来看一下这三种方法。

    首先不推荐使用stop方法,原因有两点:

    1、原则上只要一调用thread.stop()方法,线程就会立即停止,并抛出ThreadDeath error,查看了Thread的源代码后发现,原先Thread.stop0()方法是同步的,而如果我们工作线程的run()方法也是同步,那么这样会导致主线程和工作线程共同争用同一个锁(工作线程对象本身),由于工作线程在启动后就先获得了锁,所以无论如何,当主线程在调用t.stop()时,它必须要等到工作线程的run()方法执行结束后才能进行,结果会使及时性收到影响。

    2、thread.stop()是不安全的。它的不安全主要是针对于在停止该线程时会释放该线程所持有的所有的锁。一般任何进行加锁的代码块,都是为了保护数据的一致性,如果在调用thread.stop()后导致了该线程所持有的所有锁的突然释放,那么被保护数据就有可能呈现不一致性,其他线程在使用这些被破坏的数据时,有可能导致一些很奇怪的应用程序错误。

    我们来看interrupt的方法

    首先贴一段代码:

    class MyThread04 extends Thread {  
         
       public MyThread04(String threadName) {  
           super(threadName);  
       }  
    
       @Override 
       public void run() {  
             try{
            	 for (int j = 0; j<100; j++) {  
                     if(this.isInterrupted()) throw new InterruptedException();
                     System.out.println(Thread.currentThread().getName()+":"+j);
                     Thread.sleep(10000);
            	 }
            	 
             }catch (InterruptedException e) {  
    //             e.printStackTrace();  
             }  
           
              
           }  
             
    }

    或者是像下面这样写,try.catch块的范围较小,更利于调优

    class MyThread04 extends Thread {
    	public MyThread04(String threadName) {
    		super(threadName);
    	}
    
    	@Override
    	public void run() {
    		// try{
    		for (int j = 0; j < 100; j++) {
    			if (this.isInterrupted())
    				break;
    			System.out.println(Thread.currentThread().getName() + ":" + j);
    			try {
    				Thread.sleep(10000);
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				this.interrupt();// 由于处于sleep状态的线程被终止后会将标志位复位,所以需要重设一次
    				e.printStackTrace();
    			}
    		}
    	}
    }


    这里之所以抛出异常并捕获是考虑到对一个处于wait或者sleep状态的线程使用interrupt是会抛出异常的,所以需要事先捕获,主进程代码如下:

    MyThread04 t=new MyThread04("A");
    		t.start();
    		try {
    			Thread.sleep(5000);
    		} catch (InterruptedException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		t.interrupt();
    }

    使用interrupt()方法优雅的结束了进程。

    我们最后看看设置标志位的方法,代码如下:

    class MyThread04 extends Thread {
    
    	private boolean stop = false;
    
    	public MyThread04(String threadName) {
    		super(threadName);
    	}
    
    	@Override
    	public void run() {
    
    		for (int j = 0; j < 100; j++) {
    			if (this.stop == false) {
    				System.out.println(Thread.currentThread().getName() + ":" + j);
    				try {
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    			} else {
    				break;
    			}
    
    		}
    
    	}
    
    	public void setStop() {
    		this.stop = true;
    	}
    }

    只要在主进程中调用setStop()方法就可以了,但此时如果for循环之后仍有代码,那么这些代码还是会被执行,为了避免这一点,我们可以采用抛出异常的方式处理,代码如下:

    class MyThread04 extends Thread {
    
    	private boolean stop = false;
    
    	public MyThread04(String threadName) {
    		super(threadName);
    	}
    
    	@Override
    	public void run() {
    
    		try{
    			for (int j = 0; j < 100; j++) {
    				if (this.stop == false) {
    					System.out.println(Thread.currentThread().getName() + ":" + j);
    					try {
    						Thread.sleep(1000);
    					} catch (InterruptedException e) {
    						e.printStackTrace();
    					}
    				} else {
    					throw new InterruptedException();
    				}
    
    			}
    			
    		}catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		
    
    	}
    
    	public void setStop() {
    		this.stop = true;
    	}
    }




    展开全文
  • 有时开启一个线程是为了把耗时的操作转移到线程中执行,主进程中可以执行其它的任务,避免了因为大量的重复性操作导致主进程阻塞。 控制线程暂停的方法线程的同步用到了QMutex类,作为一个互斥锁控制进行保护。...

    需要线程停止的目的:

    有时开启一个线程是为了把耗时的操作转移到线程中执行,主进程中可以执行其它的任务,避免了因为大量的重复性操作导致主进程阻塞。

    控制线程暂停的方法:

    线程的同步用到了QMutex类,作为一个互斥锁控制进行保护。如果在主进程中把线程里面的互斥锁获取,那么线程中再次获取该锁就会失败,引起线程阻塞,主进程执行操作结束后,释放该锁,线程就会再次启动。以上思路实现了线程的暂停和开启。

    具体实现代码:

    1、线程中代码框架

    void thread::run(){
        mutex.lock();    //获得锁
        /*********/
        /........../
        mutex.unlock();  //释放锁
    }

    2、主进程中代码

    void mainwindows::doSomething(){
        thread.mutex.lock();
        /*****************/
        thread.mutex.unlock();
    }

    中途停止线程的方法

    Qt线程的停止可通过三种方式实现:

    1、利用quit(或者exit(0))

    this.quit();

    2、使用terminate

    this.terminate();

    this.wait();

    3、利用volatile

            一种是使用标志位,这种方法最好,在while循环中使用标志位判断是否满足进行循环的条件,并在run函数结束时将stoped置为初始化的值false。(stop定义:volatile bool stopped)

    第三中方法线程还在运行,只不过运行的内容是空的。

    测试第二中方法可以实现中途停止线程。

    展开全文
  • 在Java中停止一个线程有三种办法: 1.正常结束执行; 2.发生异常; 3.被其他线程stop(Java官方不建议) 参考:...

    在Java中停止一个线程有三种办法 :

    1.正常结束执行;

    2.发生异常;

    3.被其他线程stop(Java官方不建议)

    参考:https://docs.oracle.com/javase/8/docs/technotes/guides/concurrency/threadPrimitiveDeprecation.html

    为什么Thread.stop弃用?

    因为它本质上是不安全的。停止线程会导致它解锁已锁定的所有监视器。(当ThreadDeath异常传播到堆栈中时,监视器将被解锁。)如果先前受这些监视器保护的任何对象处于不一致状态,则其他线程现在可以以不一致的状态查看这些对象。据说这些物体已被 损坏。当线程对受损对象进行操作时,可能会导致任意行为。这种行为可能很微妙并且难以检测,或者可能是明显的。与其他未经检查的异常不同,它会 ThreadDeath默默地杀死线程; 因此,用户没有警告他的程序可能被破坏。

     

    所以如果遇到一种特殊情况某一个线程A会一直执行下去停不下来,这种情况是存在的比如那种需要持续取样的线程A,当然了在正常代码里会有“停止”功能,外部线程B可以发送停止信号给A,A可以直接结束。

    如果A线程没有这种信号量那么B线程还可以主动停止他么?答案是不可以!

    public class Test {
    
        public static void main(String args[]) throws InterruptedException {
    
            Thread thread1 = new Thread() {
                public void run() {
                    fun_a();
                }
            };
            thread1.start();
    
            int a = 0;
            while (a < 100) {
                Thread.sleep(1000);
                a++;
                if (a == 3) {
                    a = 100;
                    thread1.interrupt();
                    //thread1.stop();
                    //throw new RuntimeException("主函数抛出异常");
                }
            }
        }
    
        public static void fun_a() {
            for (; ; ) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(">> " + DateUtil.getNowTimeString());
            }
        }
    }
    

     可以看到interrupt并不能让运行中的线程停止,这个是很容易被误解的地方。这个方法的作用并不是中断线程,而是设置一个标识,通知该线程可以被中断了,到底是继续执行,还是中断返回,由线程本身自己决定。

    当对一个线程调用了interrupt()之后,如果该线程处于被阻塞状态(比如执行了wait、sleep或join等方法),那么会立即退出阻塞状态,并抛出一个InterruptedException异常,在代码中catch这个异常进行后续处理。如果线程一直处于运行状态,那么只会把该线程的中断标志设置为 true,仅此而已,所以interrupt()并不能真正的中断线程,不过在rpc调用的场景中,请求线程一般都处于阻塞状态,等待数据返回,这时interrupt()方法是可以派上用场的。

    参考:Java中如何实现线程的超时中断

     

    修改子线程的代码:

    public static void fun_a() {
            for (; ; ) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException("子线程抛出异常");
                    //e.printStackTrace();
                }
                System.out.println(">> " + DateUtil.getNowTimeString());
            }
        }

    这次是可以结束子线程,前提是子线程自己有异常捕获机制,可以接受其他线程发来的InterruptedException:

     

    主线程每隔2秒对子线程进行一次Interrupted:

    package com.t.www;
    
    public class Test {
        final static Object lock = new Object();
        volatile boolean stop = false;
    
        public static void main(String args[]) throws InterruptedException {
    
            Thread thread1 = new Thread() {
                public void run() {
                    fun_a();
                }
            };
            thread1.start();
            System.out.println("> 1 主线程start " + DateUtil.getNowTimeString());
            int a = 0;
            while (a < 3) {
                Thread.sleep(2000);
                a++;
                System.out.println("> 2 主线程对子线程开始interrupt " + DateUtil.getNowTimeString());
                thread1.interrupt();
                System.out.println("> 3 主线程对子线程完成interrupt " + DateUtil.getNowTimeString());
            }
        }
    
        public static void fun_a() {
            for (; ; ) {
                try {
                    System.out.println(">> 1 子线程wait " + DateUtil.getNowTimeString());
                    synchronized (lock) {
                        lock.wait();
                    }
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //throw new RuntimeException("子线程抛出异常");
                    e.printStackTrace();
                }
                System.out.println(">> 2 子线程完成 " + DateUtil.getNowTimeString());
            }
        }
    }
    

     

     修改子线程代码:

    try {
                    System.out.println(">> 1 子线程wait " + DateUtil.getNowTimeString());
                    synchronized (lock) {
                        lock.wait();
                    }
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //throw new RuntimeException("子线程抛出异常");
                    //e.printStackTrace();
                    System.out.println(">> 2 子线程捕获异常 " + DateUtil.getNowTimeString());
                }

    从运行结果看和前面一致,只是没有抛出异常。 

     

    修改代码子线程使用while(!Thread.currentThread().isInterrupted())判断:

    public class Test {
    
        public static void main(String args[]) throws InterruptedException {
    
            Thread thread1 = new Thread() {
                public void run() {
                    fun_a();
                }
            };
            thread1.start();
            System.out.println("> 1 主线程start " + DateUtil.getNowTimeString());
            int a = 0;
            while (a < 3) {
                Thread.sleep(2000);
                a++;
                System.out.println("> 2 主线程对子线程开始interrupt " + DateUtil.getNowTimeString());
                thread1.interrupt();
                System.out.println("> 3 主线程对子线程完成interrupt " + DateUtil.getNowTimeString());
            }
        }
    
        public static void fun_a() {
            while(!Thread.currentThread().isInterrupted()){
                try {
    
                    System.out.println(">> 1 子线程 " + DateUtil.getNowTimeString());
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //throw new RuntimeException("子线程抛出异常");
                    //e.printStackTrace();
                    System.out.println(">> 2 子线程捕获异常 " + DateUtil.getNowTimeString());
                }
                System.out.println(">> 3 子线程完成 " + DateUtil.getNowTimeString());
            }
            System.out.println(">> 4 子线程正常结束 " + DateUtil.getNowTimeString());
        }
    }
    

    可以看到这次因为子线程增加了状态判断所以可以正常结束: 

    比较优雅的方式是使用一个变量在线程间通信,需要注意的是要保证可见性:

    public class Test {
        private static volatile boolean finished = false;   // ① volatile条件变量
        public static void main(String args[]) throws InterruptedException {
    
            Thread thread1 = new Thread() {
                public void run() {
                    fun_a();
                }
            };
            thread1.start();
            System.out.println("> 1 主线程start " + DateUtil.getNowTimeString());
            int a = 0;
            while (a < 3) {
                Thread.sleep(2000);
                a++;
            }
            System.out.println("> 1 主线程 a=" +a+" "+ DateUtil.getNowTimeString());
            finished=true;
        }
    
        public static void fun_a() {
            while(!finished){
                try {
    
                    System.out.println(">> 1 子线程 " + DateUtil.getNowTimeString());
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //throw new RuntimeException("子线程抛出异常");
                    //e.printStackTrace();
                    System.out.println(">> 2 子线程捕获异常 " + DateUtil.getNowTimeString());
                }
                System.out.println(">> 3 子线程完成 " + DateUtil.getNowTimeString());
            }
            System.out.println(">> 4 子线程正常结束 " + DateUtil.getNowTimeString());
        }
    }
    

    ------------------

    如何停止线程或任务

     

    如何停止一个正在运行的java线程

    了解Java中的线程中断

    如何在Java中正确停止Thread?

    你如何杀死Java中的线程?

    如何在运行时停止/终止长时间运行的Java线程?超时 - >取消 - >中断状态

    Java - 从不同的类停止线程

    https://javaconceptoftheday.com/how-to-stop-a-thread-in-java/

    如何超时一个线程

     

    参考《Effective Java 中文版 第3版

    展开全文
  •  在java中,线程的中断(interrupt)只是改变了线程的中断状态,至于这中断状态改变后带来的结果,那是无法确定的,有时它更是让停止中的线程继续执行的唯一手段。不但不是让线程停止运行,反而是继续执行线程的...
  • 如何停止一个正在运行的线程

    千次阅读 2020-02-26 10:11:07
    虽然它确实可以停止一个正在运行的线程,但是这个方法是不安全的,而且是已被废弃的方法。 在java中有以下3种方法可以终止正在运行的线程:· 使用退出标志,使线程正常退出,也就是当run方法完成后线程终止· 使用...
  • 如何正确地结束一个线程

    千次阅读 2019-01-02 00:19:25
    一般来说,当一个线程的方法体执行完,这个方法就会结束了。我们一般不直接使用stop方法来终止线程,这可能会导致业务逻辑不完整或者破坏原子性的操作,一段代码可能用来输出某些重要的信息,在方法的执行中使用stop...
  • Java停止线程的四种方法

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

    万次阅读 2018-09-09 18:23:04
    要终止一个线程,并不是简单的调用stop()方法,stop()就像linux中的kill一个线程一样是非常暴力的,虽然在Java的API中仍然可以调用stop()方法,但是和suspend,resume方法一样,是过期了的,不建议使用的,因为stop...
  • 一个线程停止,另一个停止运行,怎么做,利用静态变量标识符控制,怎么做,求解释
  • Java中停止线程执行的方法

    千次阅读 2018-11-11 04:21:01
    Java中停止线程执行的方法
  • 【C++】线程停止方法

    千次阅读 2019-10-22 22:33:41
    【C++】线程停止的方法 最近在上计网实践课(重新拾起了c++),最近涉及用MFC抓包相关分析协议的实验,用到了多...前几次实验用了这个方法,好用但是不安全(虽然至今没遇见出BUG的情况 TerminateThread函数,同E...
  • java多线程停止方法

    千次阅读 2019-02-21 15:04:00
    一、如何让一个线程停止呢? 让线程停止有三种方法:1.设置标记位,使线程正常退出。2.使用stop()方法强制退出(不建议使用)。3.使用Thread类中提供interrupt()来中断线程。 1.1设置标记使线程退出 public ...
  • Java线程的三种停止方法

    千次阅读 2019-03-01 19:41:33
    interrupt()方法是给受阻塞的线程发出一个中断信号,这样受阻线程就得以退出阻塞的状态,只是改变中断状态而已,它不会中断一个正在运行的线程。 简单来说,一个线程在运行状态中,其中断标志被设置为true之后,...
  • 多线程的终止方法停止线程

    千次阅读 2019-07-08 23:30:07
    停止线程是多线程中的一个重要技术点,本篇文章将对线程的停止操作进行详细讲解。 停止线程不能像for或while循环中使用break停止那样直接,而是需要一些技巧来终止。 如何判断线程已终止 Thread类中提供了两...
  • 线程面试题(值得收藏)

    万次阅读 多人点赞 2019-08-16 09:41:18
    史上最强多线程面试47题(含答案),建议收藏 金九银十快到了,即将进入找工作的高峰期,最新整理的最全多线程并发面试47题和答案总结,希望对想进...可见性指多个线程操作一个共享变量时,其中一个线程对变量进行修...
  • 停止线程 欢迎使用Markdown编辑器写博客 本Markdown编辑器使用StackEdit修改而来,用它写博客,将会带来全新的体验哦: Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列...
  • Java让线程停止方法

    千次阅读 2017-04-06 10:30:14
    线程停止大家所熟知的有三种:stop、volatile、interrupt stop:建议不要用,当线程正在进行一些耗时操作如读写,突然终止很可能会有错误发生 interrupt:建议不要用,当线程进入阻塞如 Thread.sleep(5000);调用...
  • Java中如何安全终止一个线程

    万次阅读 2018-07-20 16:37:16
    在最初的JDK版本中,Thread类提供了一个线程终止的方法stop()方法,但是现在在JDK源码中发现,stop()方法已经被废弃。主要原因是:stop()方法太过暴力。强制终止一个正在执行的线程。这样的话会造成一些数据不一致...
  • Python开启多线程/停止线程方法

    千次阅读 2019-11-07 10:24:08
    import ctypes import inspect import threading import time def main(a): while True: print(a) ... # 停止线程 time.sleep(1) for thread in threadList: stop_thread(thread)  
  • 停止线程方法(interrupt)

    千次阅读 2018-05-06 22:52:20
    java中有三种停止线程方法1)使用退出标志,使线程正常退出,也就是当run方法完成后线程终止。...讲解第三种interrupt()方法 仅仅使房钱线程中打了一个停止的标记,并不是真的停止线程。代码如下:publi...
  • 停止线程会导致它解锁所有已锁定的监视器。(当ThreadDeath异常在堆栈中传播时,监视器被解锁。)如果之前由这些监视器保护的对象中的任何一个处于不一致状态,则其他线程现在可以以不一致的状态查看这些对象。据称...
  • java中如何停止一个线程

    千次阅读 2018-10-11 16:01:33
    java提供了丰富的API但没有为停止线程提供API,JDK1.0本来有一些像stop(),suspend()和resume()的控制方法但是由于潜在的死锁威胁因此在后续的JDK版本中被他们弃用了,之后java API的设计者就没有提供一个兼容...
  • 【多线程】——停止线程的三种方式

    万次阅读 热门讨论 2018-04-28 18:33:47
    前提 停止线程是在多线程开发时非常重要的...停止线程的方式有三种,分别展示一下方式使用退出标识,使得线程正常退出,即当run方法完成后进程终止。public void run() { while(flag){ //do something } }利用...
  • java多线程---停止、暂停一个线程

    千次阅读 2016-05-28 23:13:12
    2.使用interrupt方法:调用线程的这个方法会修改线程的中断标志位真,可以通过interrupted和isInterrupted这两个方法来判断线程是否已经被中断,区别是第一个方法在调用之后会把状态改为false,第二个方法则不会 ...
  • android 停止 终止 Thread 线程的三种方法
  • 在使用线程时,最麻烦的就是线程的同步控制,如... 本人经过试验和总结,整理出可以安全的进行暂停、继续、停止线程执行的一个线程类,能非常方便的对线程进行控制。 附件里是源码和Sample程序,并有详细的使用说明。
  • 在开发多线程程序时,经常由于需要重新执行任务从而取消(停止)工作线程。C++11目前并没有很好的取消线程执行的机制。那么我们应该如何实现取消线程呢? 说明 C++11使用<future>库进行线程间数据通讯,也...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 361,227
精华内容 144,490
关键字:

停止一个线程的方法