精华内容
下载资源
问答
  • Java 线程停止

    2016-02-18 20:54:50
    Java 线程停止

    Java 线程停止的方法有三种目前学习到的。

    1. stop 方法。
    2. volatile 变量控制退出。
    3. interrupt 方法。

    第一种方法官方不建议,这种停止方法会导致释放锁后线程工作来不及清理,从而会出现数据不一致。

    第二种方法写了个代码学习,如下:

    共享资源类:
    package com.lenovo.plm.dms.p6;
    
    
    public class Service {
        
        private volatile boolean requestedStoppedFlag = false;
        
        private long record;
        
        private String lock = new String();
        
        public Service(long record){
            this.record = record;
        }
        
        public void execute(){
    
    
            synchronized (lock) {
                while(true){
                    if(requestedStoppedFlag){
                        return;
                    }
                    System.out.println(Thread.currentThread().getName() + " " +record++);
                }
                
            }
        }
        public void stop(){
            
            synchronized(this){
                requestedStoppedFlag = true;
                System.out.println(Thread.currentThread().getName() + " " +record++);
            }
        }
    }
    

    线程类:
    package com.lenovo.plm.dms.p6;
    
    
    public class MyThread extends Thread {
    
    
        
        private Service service;
        
        public MyThread(Service service){
            this.service = service;
        }
        
        @Override
        public void run() {
           service.execute();
        }
    }
    

    执行类如下:

    package com.lenovo.plm.dms.p6;
    
    
    public class Main {
        
        public static void main(String[] args) {
            
            Service service = new Service(0);
            
            MyThread t1 = new MyThread(service);
            t1.start();
           
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
            service.stop();
        }
    }
    


    这里创建了两个线程并发执行。主线程等待3s后,执行停止方法。执行后,线程结束。



    第三种方法是用interrupt。见代码。
    先创建service 共享资源的类。
    package com.lenovo.plm.dms.p7;
    
    public class Service {
        
        private long record;
        private String lock = new String();
        
        public Service(long record){
            this.record = record;
        }
    
        public void execute(){
            
            synchronized(lock){            
                while(true){
                    if(Thread.interrupted()){
                        return;
                    }
                    System.out.println(Thread.currentThread().getName() + " " + record++);
                }
            }
        }  
    }
    

    其次线程类
    package com.lenovo.plm.dms.p7;
    
    public class MyThread extends Thread {
    
        private Service service;
        
        public MyThread(Service service){
            this.service = service;
        }
        
        @Override
        public void run() {
            // TODO Auto-generated method stub
            super.run();
            service.execute();
        }
        
    }
    


    最后调用:

    package com.lenovo.plm.dms.p7;
    
    public class Main {
        
        public static void main(String[] args) {
            
            Service service = new Service(0);
            MyThread t = new MyThread(service);
            t.start();
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
            t.interrupt();
            
            try {
                t.join();
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
            System.out.println(t.isAlive());
            
        }
    }
    

    执行结果是线程被停止了。



    这三种方法理解如下:
    第一种跳过。
    第二种使用了volatile关键字,这个关键字可以保证线程每次读取该变量时,都是直接从主内存中读取,不会直接读线程内存中的值。这样,可以确保线程每次读到的值,都是最新的。因此有线程修改了这个变量,那么
    当前执行的线程会马上知道,因此可以作为线程间通信的方法。

    第三种使用了线程自身的方法来检查中断状态位。




    展开全文
  • JAVA 线程停止

    2021-03-06 21:38:58
    //测试线程停止 //1.建议线程正常停止-----利用次数,不建议死循环 //2.建议使用标志位-------设置一个标志位 //3.不要使用stop,destroy等过时或JDK不建议的方法 public class TestStop implements Runnable{ //...

    之前使用过sleep来停止线程

    我们这次使用别的方法来停止线程

    //测试线程停止
    //1.建议线程正常停止-----利用次数,不建议死循环
    //2.建议使用标志位-------设置一个标志位
    //3.不要使用stop,destroy等过时或JDK不建议的方法
    public class TestStop implements Runnable{
        //设置一个标志位
        private boolean flag = true;
        @Override
        public void run() {
            int i = 0;
            while (flag){
                System.out.println("the thread is runing...."+i++);
            }
        }
        //设置一个停止方法
        public void stop(){
            this.flag = false;
        }
    
        public static void main(String[] args) {
            TestStop testStop = new TestStop();
            new Thread(testStop).start();
            for (int i = 0; i < 100; i++) {
                System.out.println("this is main thread "+i);
                if (i == 50){
                    testStop.stop();
                    System.out.println("the thread is stop.");
                }
            }
        }
    }

    执行结果如下:

    可以看到,当主线程到50时,我们更改了run线程的标志位 使它停止  此时run线程跑到了93的地方,主线程并没有停止,他要跑完了才不跑

    使用标志位来停止线程,是一个比较建议的做法

    展开全文
  • Java线程停止

    2018-11-26 19:20:29
    线程中有三种方法可以停止线程 设置标记位,可以使线程正常退出 使用stop方法强制使线程退出,但是这个方法不太安全已经被废弃 使用Thread类中的一个interrupt()可以中断线程 标记位 举例: class MyThread ...

    多线程中有三种方法可以停止线程

    1. 设置标记位,可以使线程正常退出
    2. 使用stop方法强制使线程退出,但是这个方法不太安全已经被废弃
    3. 使用Thread类中的一个interrupt()可以中断线程

    标记位

    举例:

    class MyThread implements Runnable{
        volatile boolean flag = true;
        int i = 0;
        @Override
        public void run() {
           while(flag){
    
               System.out.println(Thread.currentThread().getName()+ i++);
               try {
                   sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        }
    }
    
    public class Test{
        public static void main(String[] args) throws InterruptedException {
            MyThread myThread = new MyThread();
            Thread t1 = new Thread(myThread,"子线程");
            t1.start();
            sleep(2000);
            myThread.flag = false;
            System.out.println("结束");
        }
    }
    

    运行结果:

    子线程0
    子线程1
    子线程2
    结束
    
    

    这个方法就是设置一个标记位,然后在主方法中对标记位进行修改,从而控制线程的运行。

    stop方法

    在JDK1.2以前可以使用stop()方法来停止线程。但是,JDK1.2之后,该方法就被废弃了。
    为什么被废弃呢?
    因为stop()方法太过直接,会强行把执行一半的线程终止。当在一个线程对象上调用stop()方法时,这个线程对象 所运行的线程就会立即停止,假如一个线程正在执行:synchronized void { x = 3; y = 4;} 由于方法是同步的,多个 线程访问时总能保证x,y被同时赋值,而如果一个线程正在执行到x = 3;时,被调用了 stop()方法,即使在同步块中, 它也会马上stop了,这样就产生了不完整的残废数据。所以会导致程序工作在不确定的状态下造成数据的不同步。

    interrupt方法

    interrupt() 方法只是改变中断状态而已,它不会中断一个正在运行的线程。这一方法实际完成的是,给受阻塞的线 程发出一个中断信号,这样受阻线程就得以退出阻塞的状态。

    在JVM中,每个线程都有一个与自己中断状态相关的Boolean属性,称为中断状态。可以通Thread.currentThread().isInterrupted()来获取当前线程的中断状态,初始值为false。

    而interrupt()方法只会给线程设置一个为true的中断标志。

    由于Thread.currentThread().isInterrupted()可以直接获取到中断状态所以有的人可能会写下面的代码:

    不推荐:

    class MyThread implements Runnable{
       
        int i = 0;
        @Override
        public void run() {
           while(!Thread.currentThread().isInterrupted()){
    
               System.out.println(Thread.currentThread().getName()+ i++);
           }
        }
    }
    
    public class Test{
        public static void main(String[] args) throws InterruptedException {
            MyThread myThread = new MyThread();
            Thread t1 = new Thread(myThread,"子线程");
            t1.start();
            sleep(1);
            t1.interrupt();
            System.out.println("结束");
        }
    }
    

    运行结果:

    子线程0
    子线程1
    子线程2
    子线程3
    子线程4
    子线程5
    子线程6
    子线程7
    结束
    

    但是一般不推荐使用,因为如果线程当前状态处于非阻塞状态,那么仅仅是线程的中断标志被修改为true而已;如果线程当前状态为阻塞状态(使用了wait、sleep、join方法发导致线程阻塞),那么在将中断设置为true后,interrupt()会在线程中抛出InterruptException异常、并且将线程的中断状态由true设置为false。
    举例:

    class MyThread implements Runnable{
        int i = 0;
        @Override
        public void run() {
           while(!Thread.currentThread().isInterrupted()){
    
               System.out.println(Thread.currentThread().getName()+ i++);
               try {
                   sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
        }
    }
    
    public class Test{
        public static void main(String[] args) throws InterruptedException {
            MyThread myThread = new MyThread();
            Thread t1 = new Thread(myThread,"子线程");
            t1.start();
            sleep(2000);
            t1.interrupt();
            System.out.println("结束");
        }
    }
    

    运行结果:

    子线程0
    子线程1
    结束
    java.lang.InterruptedException: sleep interrupted
    子线程2
    	at java.lang.Thread.sleep(Native Method)
    	at www.bit.java.MyThread.run(Test.java:675)
    	at java.lang.Thread.run(Thread.java:748)
    子线程3
    子线程4
    子线程5
    

    如上面代码所示:程序抛出异常,并且不会被中断。这就是因为sleep语句使线程阻塞,抛出异常,且中断标志会被程序自动清除重置为false。

    正确写法:

    lass MyThread implements Runnable{
        volatile boolean flag = true;
        int i = 0;
        @Override
        public void run() {
           while(flag){
               try {
                   boolean bool = Thread.currentThread().isInterrupted();
                   System.out.println(Thread.currentThread().getName()+ i++);
                   sleep(1000);
               } catch (InterruptedException e) {
                   /**
                    * 这里退出阻塞状态,且中断标志被系统会自动清除
                    * 重置为false
                    */
                   boolean bool = Thread.currentThread().isInterrupted();
                   System.out.println("3.重置中断为" + bool);
                   return ;
               }
           }
        }
    }
    
    public class Test{
        public static void main(String[] args) throws InterruptedException {
            MyThread myThread = new MyThread();
            Thread t1 = new Thread(myThread,"子线程");
            t1.start();
            sleep(3000);
            t1.interrupt();
        }
    }
    

    运行结果:

    子线程0
    子线程1
    子线程2
    3.重置中断为false
    

    通过上面的分析可以得出,调用线程类的interrupted方法,其本质只是设置该线程的中断标志,将中断标志设置为true,并根据线程状态决定是否抛出异常。

    补充:Thread.interrupted()是获取并清除当前线程的状态,
    Thread.currentThread().isInterrupted()只是获取当前线程的中断状态,并不清除当前线程的中断状态。

    展开全文
  • JAVA线程停止的方法

    2012-01-30 14:10:52
    JAVA线程停止的方法
  • Java线程停止的方法

    2017-09-13 11:24:00
    Java线程停止的方式 可以调用stop()方法,但是该方法已经被停用,同时该方法会使线程当前未完成的任务丢失 可以调用interrupt()方法标记当前线程为停止状态,在线程中调用isInterrupted()方法,如果该方法返回...

    Java线程停止的方式

    • 可以调用stop()方法,但是该方法已经被停用,同时该方法会使线程当前未完成的任务丢失
    • 可以调用interrupt()方法标记当前线程为停止状态,在线程中调用isInterrupted()方法,如果该方法返回true,进行停止线程操作(return,throw),interrupt、interrupted 、isInterrupted 详解

    下面演示线程的两种停止方法

    stop()方法停止


    public class ThreadStopTest {
    
        public static void main(String[] args) {
            StopThread stopThread = new StopThread();
            Thread t = new Thread(stopThread);
            t.start();
            try {
                Thread.sleep(50);
            } catch (InterruptedException ignore) {
                // ignore this exception
            }
            t.stop();
        }
    
    }
    
    class StopThread implements Runnable {
    
        @Override
        public void run() {
            System.out.println("thread is start");
            for (int i = 0; i < 10000000; i++) {
                System.out.println(i);
            }
        }
    }

    运行结果:
    运行结果

    interrupt()方法停止


    public class ThreadInterruptTest {
        public static void main(String[] args) {
            InterruptThread interruptThread = new InterruptThread();
            Thread t = new Thread(interruptThread);
            t.start();
            try {
                Thread.sleep(50);
            } catch (InterruptedException ignore) {
                // ignore this exception
            }
            t.interrupt();
        }
    }
    
    class InterruptThread implements Runnable {
    
        @Override
        public void run() {
            System.out.println("thread is start");
            for (int i = 0; i < 10000000; i++) {
                if (Thread.currentThread().isInterrupted()) {
                    return;
                }
                System.out.println(i);
            }
        }
    }

    运行结果:
    运行结果

    用stop()停止线程,在线程中无法得知,对未完成任务无法处理,使用interrupt()停止,在线程中能够进行判断,对于未完成任务能够进行处理

    转载于:https://my.oschina.net/ikiru/blog/1536632

    展开全文
  • Java线程停止的坑

    2020-06-28 22:53:10
    复杂点的Java应用一般都会开多个线程在后台跑程序,有时候因为发布或其他原因需要停止程序,那就涉及到如何停止Java线程的问题.Java 的线程停止还是比较别扭的,如果是从其他语言转学j...
  • java线程停止interrupt

    2017-10-25 16:57:28
    说明: 线程在运行过程中可能需要根据条件判断进行停止,从api上开是可以使用stop方法强制终止线程,但是官方不推荐这个方法,这个是作废过期的方法,因为如果强制让线程停止则有可能使一些清理性的工作得不到完成,...
  • Java线程停止和休眠

    2021-05-31 21:01:15
    线程停止 使用一个标志位来停止线程 //建议使用标志性 设置一个标志位 ​ public class Thread4 implements Runnable{ private boolean flag =true; @Override public void run() { int i = 0; while(flag){...
  • java线程停止【二】

    千次阅读 2012-08-20 22:19:23
     如上一篇java线程停止【一】,利用cancelled标志在一定场景可以停止线程任务,然而在某些场景,利用cancelled标志可能让任务陷入死循环。例如:生产者-消费者模式中,如果生产者生成速度超过消费者速度,那么生产...
  • JDK1.0定义了stop和suspend方法,stop用来直接终止线程,suspend会阻塞线程直到另一个线程调用resume. stop和suspend都有一些共同的点:都试图专横...网上有很多关于Java线程停止、暂停的文章,经过自己测试,在这里总结
  • java线程停止问题

    2016-03-02 16:17:13
    线程的挂起操作suspend已经被java所摒弃,原因在于它会导致死锁,加入一个线程拥有了某个资源时被挂起,那么等待该资源释放的其他线程将会无法得到该资源,会陷入 死锁,那么和suspend配套使用的resume也被摒弃。 ...
  • java线程停止之interrupt

    2020-05-17 13:58:07
    今天笔者学习了中断线程interrupt的方式,故在此分享下,话不多说直接上代码 public class InterruptDemo02 implements Runnable{ @Override public void run() { while(!Thread.currentThread().isInterrupted()...
  • 最近在学习Java多线程相关的知识点,其中关于线程停止的方法网上也有不少大牛给出了详细的解答,而我这边就其中Interrupt方法的注意点给自己提个醒。  首先还是大概的罗列下停止线程的方法:  1、使用stop()方法...
  • java线程停止的几种方法

    万次阅读 2018-09-09 18:23:04
    要终止一个线程,并不是简单的调用stop()方法,stop()就像linux中的kill一个线程一样是非常暴力的,虽然在Java的API中仍然可以调用stop()方法,但是和suspend,resume方法一样,是过期了的,不建议使用的,因为stop...
  • 什么是JAVA线程停止?  前段时间,我还自认为线程的停止,指的是线程的销毁。如果我停止一个线程,那么这个线程将会被销毁,至于如何销毁,那都是JVM应该考虑的事情,我只需调用对应 的API(比如Thread....
  • 有三种方法可以使终止线程。 1. 使用退出标志,使线程正常退出,也就是当run方法完成后线程终止。 2. 使用stop方法强行终止线程(这个方法不推荐使用,因为...如何停止java线程一直是一个困恼我们开发多线程程序...
  • java 线程停止的方法

    2014-09-09 12:00:18
    线程停止的方法: 记住一点,线程的停止, 1.自己运行完了, 2.如果是无限循环,在外部,只能用flag标记来操作。 但是当线程处于冻结状态(阻塞),sleep,wait,join,(这三个方法抛出异常。) 就不会读取...
  • public final void stop(): 让线程停止,方法过失了,但还可以用 public void interrupt(): 中断线程,并抛出InterruptedException,程序正常结束 实验代码 public class ThreadSleepDemp { public static void ...
  • 要终止一个线程,并不是简单的调用stop()方法,stop()就像linux中的kill一个线程一样是非常暴力的,虽然在Java的API中仍然可以调用stop()方法,但是和suspend,resume方法一样,是过期了的,不建议使用的,因为stop...
  • java线程停止的方法

    2016-05-29 12:18:30
    之前介绍过,停机线程可以使用interrupte ,可以用标记,让run执行结束。现在我们来看几个方法。 方法1、使用interrupte方法来执行,通过抛出InterruptedException来结束run运行。packagesecondThreadStudy; import...
  •  中断(Interrupt)一个线程意味着在该线程完成任务之前停止其正在进行的一切,有效地中止其当前的操作。线程是死亡、还是等待新的任务或是继续运行至下一步,取决于这个程序。虽然初次看来它...

空空如也

空空如也

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

java线程停止

java 订阅