java中终止程序的执行

Posted 2023-04-13

现在我在做的是一个java GUI,功能是点击一个按钮会执行一段代码，这段代码要执行的时间很长，如果执行一半的时候不想再继续，则点击另外一个按钮停止代码的执行。这个停止执行应该怎么实现呢？各位大哥大姐帮帮忙，急.......分数不多，如果可用，一定加分。谢谢

方案操作如下：

（1）让程序在一个单独的线程中运行，然后在终止时，可以用线程的终止方法来结束它。

（2）退出Java程序时尽量不要使用java.lang.System的exit方法。Exit 方法可以终止JVM，从而终止程序，但如果同时运行了另一个Java程序，使用exit方法就会让该程序也关闭，这显然不是希望看到的情况！！！！

要退出Java程序，可以使用destory()退出一个独立运行的过程。对于多线程程序，必须要关闭各个非守护线程。

只有在程序非正常退出时，才使用exit方法退出程序

http://www.baidu.com/s?wd=52095384130

参考技术A

在java程序中，可以使用java.lang.System的exit方法来终止程序的执行，

public static void main(String[] args) 
System.out.println("开始进入程序...");
//do something
System.out.println("程序准备退出了！");
System.exit(0);
//下面这句话将不会打印出来
System.out.println("程序已经退出了!");

但是使用exit方法的本质是终止了JVM的运行，如果同时运行了另外一个程序，使用exit方法同样也会使该程序也终止，要避免此种情况可以使用interrupt()来中断退出一个独立运行的过程。对于多线程程序，必须要关闭各个非守护线程。

public static void main(String[] args) 
System.out.println("开始进入程序...");
//do something
new Thread()
public void run() 
while (true) 
System.out.println("我是另外的线程...");
try 
Thread.sleep(2000);
 catch (InterruptedException e) 
// TODO Auto-generated catch block
e.printStackTrace();



.start();

//获取man线程
Thread main = Thread.currentThread();
System.out.println(main.getName());
main.interrupt();
System.out.println("main线程已经退出了，但是不影响其他线程运行!");

只有在程序非正常退出时，才使用exit方法退出程序。

参考技术B 你这个要用到多线程了，
如果你不用多线程，程序运行时，你是点不到按钮的。
多线程的停止方法是Thread.stop();
但现在已不推荐这么使用，一般都是加一个标志，
如运行时flag=true;
停止设置flag=false;

public void run()
while(flag)
//你的执行长时间代码

参考技术C 想直接整个程序的结束用System.exit(0);
如果是在for循环，while或if中尝试用return ，break等

参考资料：JAVA API

本回答被提问者采纳 参考技术D 利用多线程： 单独开启一个线程A执行你的耗时很长的代码段，点击停止按钮后，挂起或者中断线程A。

java 线程的终止与线程中断

当run方法执行完后，线程就会退出。但有时run方法是永远不会结束的。如在服务端程序中使用线程进行监听客户端请求，或是其他的需要循环处理的任务。在这种情况下，一般是将这些任务放在一个循环中，如while循环。如果想让循环永远运行下去，可以使用while（true）{……}来处理。但要想使while循环在某一特定条件下退出，最直接的方法就是设一个boolean类型的标志，并通过设置这个标志为true或false来控制while循环是否退出。

关于线程终止：

　1、一般来讲线程在执行完毕后就会进入死亡状态，那该线程自然就终止了。

　2、一些服务端的程序，可能在业务上需要，常驻系统。它本身是一个无穷的循环，用于提供服务。那对于这种线程我们该如何结束它呢。

　一、线程的终止 

　　在Thread类中JDK给我们提供了一个终止线程的方法stop(); 该方法一经调用就会立即终止该线程，并立即释放对象锁。如果当一个线程执行一半业务而调用了该方法，可能就会产生数据不一致问题。

　　数据一致性：同一时间点，你在节点A中获取到key1的值与在节点B中获取到key1的值应该都是一样的。

　　例如：数据库中维护一张用户 student 表 ，表里有两条数据 ： 

id=1 name="大A"
id=2 name="小a"

如果我们使用一个 Student 对象来保存这些记录，那么该对象要么保存id=1 de 记录 ,  要么保存id=2的记录。如果这个Student对象一半保存id=1的记录 一半保存id=2 的记录（即  id=1 name="小a"）， 那么数据就出现了数据一致性问题。

看图来说明stop为什么会产生数据一致性问题：

　　读与写操作每次都要活的student对象锁，只有获得该锁的线程才有权利操作该对象，也就是说student对象锁的作用就是为了维护对象的一致性，如果线程在写入数据写到一半时 ，调用stop方法，那该对象就会被破坏同时也会释放该对象锁，另外一个等待该锁的读线程就会获得锁，执行操作读到的数据显然是错误的。

代码示例：

public class StopTest2 {
    private static Student student=new Student();
    public static void main(String[] args) {
        new Thread(new Thread_read()).start();
        while(true){
            Thread thread_writer=new Thread(new Thread_writer());
            thread_writer.start();
            try {
                Thread.sleep(1500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            thread_writer.stop();
        }
    }
    static class Thread_read implements Runnable{
        @Override
        public void run() {
            while(true){
                synchronized (student){//对共享资源加锁，使读写分离互不影响 ，维护对象的一致性
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if(student.getId()!=Integer.parseInt(student.getName())){
                        System.out.println("错误资源："+student);
                    }else{
                        System.out.println("正确资源："+student);
                    }
                }
                Thread.yield();//释放cup执行权
            }
        }
    } 
    static class Thread_writer implements Runnable{
        @Override
        public void run() {
            while(true){
                synchronized (student){//对共享资源加锁，使读写分离互不影响，维护对象的一致性
                    int mm=new Random().nextInt(10);
                    student.setId(mm);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    student.setName(String.valueOf(mm));
                }
                Thread.yield();//释放cup执行权
            }
        }
    } 
}
class Student{
    private int id=0;
    private String name="0";
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + "]";
    }
}

View Code

执行结果：

错误资源：Student [id=5, name=8]
错误资源：Student [id=4, name=8]
错误资源：Student [id=2, name=5]

如何让正确的终止线程：由程序自行决定线程的终止时间。定义一个标识，通过改变标识来控制程序是否执行。

    static class Thread_writer implements Runnable{
        private boolean flag=false;
        public void setFlag(boolean flag){
            this.flag=flag;
        }
        @Override
        public void run() {
            while(!flag){
                synchronized (student){//对共享资源加锁，使读写分离互不影响，维护对象的一致性
                    int mm=new Random().nextInt(10);
                    student.setId(mm);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    student.setName(String.valueOf(mm));
                }
                Thread.yield();//释放cup执行权
            }
        }
    }

View Code

二、线程的中断

在上面我们发现使用stop终止线程会照成数据一致性问题，于是我们通过控制标识来控制线程的终止，那JDK有没有合适的终止线程的方式呢？那就就是“线程中断” 　　

线程中断就是让目标线程停止执行，但它不会使线程立即终止，而是给线程发送一个通知，告诉线程jvm希望你退出执行，至于目标线程何时退出，则完全由它自己决定（如果立即停止，会造成与stop一样的问题）。

JDK中线程中断相关的三个方法：

//线程中断 
public void interrupt(){}
//判断线程是否中断
public boolean isInterrupted() {}
//判断线程是否中断，并清除当前中断状态
public static boolean interrupted(){}

1、使用线程中断就一定会中断线程吗？

public class InterruptTest {
    public static void main(String[] args) {
        Thread thread=new Thread(){
            @Override
            public void run() {
                while(true){
                    System.out.println("========true======");
                }
            }
        };
        thread.start();
        try {
            Thread.sleep(0);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt();//调用线程中断方法
    }
}

View Code

运行该代码发现该线程并没有终止。

2、如何终止线程

public class InterruptTest {
    public static void main(String[] args) {
        Thread thread=new Thread(){
            @Override
            public void run() {
                while(true){
                    if(this.isInterrupted()){//判断当前线程是否是中断状态
                        System.out.println("========true======");
                        break;
                    }
                }
            }
        };
        thread.start();
        try {
            Thread.sleep(0);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread.interrupt();//调用线程中断方法
    }
}

View Code

看代码可以发现这与我们自行控制线程的终断类似。

3、当interrupt() 遇到 sleep() / join ()/wait()时 ，在这里以sleep() 为例子

 public static native void sleep(long millis) throws InterruptedException;

看源码可知sleep() 方法  InterruptedException 中断异常，该异常不是运行时异常，所以需要捕获它，当线程在执行sleep()时，如果发生线程中断，这个异常就会产生。该异常一旦抛出就会清除中断状态。

看代码：

public class InterruptTest {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(){
            @Override
            public void run() {
                while(true){
                    System.out.println("线程状态"+this.isInterrupted());
                    if(Thread.currentThread().isInterrupted()){//判断当前线程是否是中断状态
                        System.out.println("========true======");
                        break;
                    }
                    try {
                        Thread.sleep(1000);
                        System.out.println("===========sleep()结束===========");
                    } catch (InterruptedException e) {
                        System.out.println("异常："+e.getMessage());
                       // Thread.currentThread().interrupt();
                    }
                }
            }
        };
        thread.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("=========interrupt()=============");
        thread.interrupt();//调用线程中断方法
    }
}

View Code

执行结果：

线程状态false
=========interrupt()=============
异常：sleep interrupted
线程状态false
===========sleep()结束===========
线程状态false
===========sleep()结束===========
线程状态false
===========sleep()结束===========

View Code

由于线程中断的状态被 InterruptedException  异常清除了，所以if（）条件中的状态一直是false ，因此该线程不会被终止。如果去掉注释就可以达到线程终止的目的（再次中断自己，设置中断状态）。