Что это значит, когда ошибка не приводит к сбою программы

Ошибки программирования можно разделить на следующие категории:

1. Ошибки времени компиляции, которые обнаруживаются компилятором во время компиляции и без их исправления, невозможно запустить программу вообще.
2. Ошибки времени выполнения, которые не обнаруживаются компилятором, но ставят компьютер в ситуацию, когда он не может понять, что делать самостоятельно, например, необработанные исключения. В большинстве случаев это приведет к сбою программы во время выполнения и сбою.
3. Логические ошибки, которые вполне приемлемы для компьютера, поскольку это действующая компьютерная программа, но не дают ожидаемого результата. Компьютер не может их поймать, поскольку компьютер не знает вашего намерения.

На практике хорошо, когда ошибки становятся смертельными, как только они возникают. Это позволяет нам быстрее находить их и легче исправлять. Вот почему в «более безопасных» языках, таких как Java, мы проверили исключения, а необработанные исключения приведут к немедленному сбою приложения, вместо продолжения работы и, вероятно, выдачи неверных результатов.

Я предполагаю, что в вашем случае все зависит от того, в каком потоке произошло исключение (ваше приложение - это приложение с графическим интерфейсом, верно?). Если в вашем основном потоке возникает исключение, оно может быть конечным, но если оно возникает в другом потоке, оно не является конечным. Это терминал для основного потока, если другие потоки в приложении являются потоками демона. Когда потоки являются демонами, приложение завершает работу до их завершения, независимо от их статуса. Если они не являются демонами, приложение будет ждать их завершения перед завершением.

Я не очень хорошо знаком с фреймворком Eclipse, но полагаю, что он может справиться с исключением в потоке графического интерфейса.

Я включил образец java-приложения, иллюстрирующий мой пример;

public class ThreadTest {

    public static void main(String[] args) {

        Runnable test = new Runnable() {

            public void run() {
                try {
                    System.out.println("Sleeping");
                    Thread.sleep(5000);
                    System.out.println("Slept");
                } catch (InterruptedException e) {
                }
            }
        };

        Thread t = new Thread(test);
        //t.setDaemon(true);
        t.start();

        System.out.println("Waiting to fail");
        throw new RuntimeException("Error");
    }
}

Вы увидите разницу в поведении, сняв отметку со строки t.setDaemon (true).

Например, представьте себе программу, используемую вашим банком.

В вашем сберегательном счете они сделали следующую строчку:

Account -= Interest;

Что, очевидно, является ошибкой, но не приводит к сбою системы.

Предыдущий ответ дает java-часть этого права:

If an exception occurs in your main thread, it may be terminal, but if it occurs in another thread it is not terminal. It's terminal for the main thread if the other threads in the application are daemon threads.

Гораздо важнее то, что JVM, в которой запущено ваше приложение, выключится, если не будет запущенных потоков, не являющихся демонами. Это или явный вызов System.exit (или явный сбой JVM) - единственные способы полного выхода из JVM.

Во многих более простых приложениях Java есть только 1 поток, не являющийся демоном (поток, в котором JVM запустила ваш main () при запуске). Потому что в простом случае поток, выполняющий наш код, является единственным потоком, не являющимся демоном. thread, создается впечатление, что необработанное исключение вызывает завершение работы JVM. Это неверно, если только этот поток не является единственным оставшимся потоком, не являющимся демоном.

Вы можете убедиться в этом сами с помощью следующей небольшой программы:

public class TestMain {
    public static void main(String[] args) {
        Thread t1 = new Thread() {
            public void run() {
                while(true) {
                    System.out.println("A");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        System.out.println("t1 interrupted.");
                    }
                }
            }
        };
        t1.setDaemon(false);

        Thread t2 = new Thread() {
            public void run() {
                int count = 0;
                while(true) {
                    if (count < 5) {
                        System.out.println("B");
                        count++;
                    } else {
                        throw new RuntimeException("Intentional RuntimeException!");
                    }
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        System.out.println("t2 interrupted.");
                    }
                }
            }
        };
        t2.setDaemon(false);
        t1.start();
        t2.start();
    }
}

Если вы запустите это, вы заметите, что вы смешиваете «A» и «B» до 5-го «B», после чего вы получите трассировку стека исключения, которое мы сгенерировали, и «A» ' s continue («B» не продолжаются, потому что этот поток просто умер из-за необработанного исключения.)

Теперь, если вы вернетесь и измените t1.setDaemon(false) на t1.setDaemon(true) и запустите снова, вы увидите, что, когда t2 завершается из-за исключения, не остается никаких потоков, не являющихся демонами, и JVM завершает работу.

Это отвечает на вопрос "почему некоторые ошибки не закрывают JVM". Но он не отвечает на часть вопроса о том, почему в Eclipse появляется отладчик.

Ответ на этот вопрос проще (но я немного менее уверен в этом ... вмешивается кто-то другой): отладчик Eclipse приостанавливается каждый раз, когда поток умирает из-за необработанного исключения. Предполагается, что вы не имели ввиду, что поток умирает, и что вам нужно исправить ошибку. Я считаю, что он на самом деле наблюдает за исключением java.lang.ThreadDeath и приостанавливает его каждый раз, когда оно возникает.