Когда мы должны вызывать System.exit в Java

В Java, в чем разница с или без System.exit(0)в следующем коде?

public class TestExit
{      
    public static void main(String[] args)
    { 
        System.out.println("hello world");

        System.exit(0);  // is it necessary? And when it must be called? 
    }      
}

В документе говорится: «Этот метод никогда не возвращается нормально». Что это означает?

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

«Этот метод никогда не возвращается нормально». просто означает, что метод не вернется; как только нить идет туда, она не вернется.

Другой, может быть, более распространенный способ выхода из программы - просто достичь конца mainметода. Но если запущены какие-либо потоки, не являющиеся демонами, они не будут закрыты, и, следовательно, JVM не выйдет. Таким образом, если у вас есть такие потоки, не являющиеся демонами, вам нужны другие средства (кроме ловушек завершения), чтобы закрыть все потоки, не являющиеся демонами, и освободить другие ресурсы. Если нет других потоков, не являющихся демонами, возврат из него mainотключит JVM и вызовет перехватчики завершения работы.

По некоторым причинам, перехватчики отключения кажутся недооцененным и неправильно понятым механизмом, и люди заново изобретают колесо с помощью всевозможных запатентованных пользовательских хаков для выхода из своих программ. Я хотел бы поощрять использование крюков отключения; все это есть в стандартной среде выполнения, которую вы будете использовать в любом случае.

В этом случае это не нужно. Никаких дополнительных потоков не будет запущено, вы не меняете код выхода (по умолчанию 0) - в основном это бессмысленно.

Когда в документах говорится, что метод никогда не возвращается нормально, это означает, что следующая строка кода фактически недоступна, даже если компилятор этого не знает:

System.exit(0);
System.out.println("This line will never be reached");

Либо будет выдано исключение, либо виртуальная машина прекратит работу перед возвратом. Он никогда не "просто вернется".

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

System.exit(0)завершает JVM. В таких простых примерах трудно понять разницу. Параметр передается обратно в ОС и обычно используется для указания аварийного завершения (например, какой-то фатальной ошибки), поэтому, если вы вызвали java из командного файла или сценария оболочки, вы сможете получить это значение и получить представление если заявка была успешной.

Это оказало бы большое влияние, если бы вы вызвали System.exit(0)приложение, развернутое на сервере приложений (подумайте об этом, прежде чем попробовать).

Метод никогда не возвращается, потому что это конец света, и следующий код не будет выполнен.

Ваше приложение в вашем примере будет в любом случае завершать работу в том же месте кода, но, если вы используете System.exit. у вас есть возможность вернуть пользовательский код в среду, например, скажем,

System.exit(42);

Кто будет использовать ваш код выхода? Скрипт, который вызывает приложение. Работает в Windows, Unix и других скриптовых средах.

Зачем возвращать код? Сказать что-то вроде «Мне не удалось», «База данных не ответила».

Чтобы узнать, как получить значение кода выхода и использовать его в сценарии оболочки Unix или сценарии Windows cmd, вы можете проверить этот ответ на этом сайте.

В приложениях, которые могут иметь сложные ловушки завершения работы, этот метод не должен вызываться из неизвестного потока. System.exitникогда не завершается нормально, потому что вызов будет заблокирован до завершения JVM. Это похоже на то, что любой код, на котором выполняется отключение питания, прежде чем он сможет завершить работу. Вызов System.exitбудет инициировать перехватчики завершения программы и любой поток, который вызывает, System.exitбудет блокироваться до завершения программы. Это подразумевает, что, если хук завершения работы, в свою очередь, отправляет задачу потоку, из которого System.exitбыл вызван, программа будет заблокирована.

Я обрабатываю это в моем коде с помощью следующего:

public static void exit(final int status) {
    new Thread("App-exit") {
        @Override
        public void run() {
            System.exit(status);
        }
    }.start();
}

Хотя ответ был действительно полезным, но кое-как он упустил некоторые дополнительные детали. Я надеюсь, что ниже поможет понять процесс завершения работы в Java, в дополнение к ответу выше:

1. При правильном * отключении JVM сначала запускает все зарегистрированные прерывания отключения. Завершение работы - это незапущенные потоки, которые зарегистрированы в Runtime.addShutdownHook.
2. JVM не дает никаких гарантий относительно порядка запуска отключающих крюков. Если какие-либо потоки приложения (daemon или nondeemon) все еще работают во время завершения работы, они продолжают работать одновременно с процессом завершения работы .
3. Когда все перехватчики завершения завершены, JVM может выбрать запуск финализаторов, если runFinalizersOnExit имеет значение true, и затем останавливается.
4. JVM не пытается останавливать или прерывать какие-либо потоки приложений, которые все еще работают во время завершения работы; они внезапно прекращаются, когда JVM в конце концов останавливается.
5. Если перехватчики завершения работы или финализаторы не завершаются, то процесс упорядоченного завершения работы «зависает», и JVM должна быть внезапно закрыта.
6. При внезапном отключении JVM не требуется делать что-либо кроме остановки JVM; отключающие крючки не будут работать.

PS: JVM может отключиться упорядоченным или резким образом.

1. Упорядоченное завершение запускается, когда завершается последний «нормальный» (не-демон) поток, кто-то вызывает System.exit или другими специфическими для платформы средствами (такими как отправка SIGINT или нажатие Ctrl-C).
2. Хотя вышеуказанное является стандартным и предпочтительным способом завершения работы JVM, его также можно внезапно отключить, вызвав Runtime.halt или убив процесс JVM через операционную систему (например, отправив SIGKILL).

НИКОГДА не следует звонить System.exit(0)по этим причинам:

1. Это скрытое «goto» и «gotos» нарушают поток управления. В этом контексте опора на ловушки - это ментальное отображение, о котором должен знать каждый разработчик в команде.

2. Выход из программы «обычно» предоставляет тот же код выхода для операционной системы, что System.exit(0)и является избыточным.

   Если ваша программа не может выйти «нормально», вы потеряли контроль над своей разработкой [дизайном]. Вы должны всегда иметь полный контроль над состоянием системы.

3. Проблемы программирования, такие как запуск потоков, которые не были остановлены, обычно становятся скрытыми.
4. Вы можете столкнуться с несогласованным состоянием приложения, которое прерывает потоки ненормально. (См. № 3)

Кстати: возврат кодов возврата, отличных от 0, имеет смысл, если вы хотите указать на ненормальное завершение программы.

Нужен System.exit

• когда вы хотите вернуть код ошибки, отличный от 0
• когда вы хотите выйти из вашей программы не из main ()

В вашем случае он делает то же самое, что и простой возврат из основного.

Спецификация языка Java говорит, что

Выход из программы

Программа завершает всю свою деятельность и завершается, когда происходит одно из двух:

Все потоки, которые не являются потоками демона, завершаются.

Некоторые потоки вызывают метод выхода класса Runtime или класса System , и операция выхода не запрещена менеджером безопасности.

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

Если в JVM запущена другая программа и вы используете System.exit, эта вторая программа также будет закрыта. Представьте, например, что вы выполняете задание Java на узле кластера и что Java-программа, которая управляет узлом кластера, выполняется в той же JVM. Если задание будет использовать System.exit, оно не только завершит задание, но и «завершит работу всего узла». Вы не сможете отправить другое задание на этот узел кластера, поскольку программа управления была случайно закрыта.

Поэтому не используйте System.exit, если вы хотите иметь возможность управлять своей программой из другой Java-программы в той же JVM.

Используйте System.exit, если вы хотите нарочно закрыть полную JVM и если вы хотите воспользоваться возможностями, описанными в других ответах (например, перехватчики завершения работы : перехват завершения работы Java , ненулевое возвращаемое значение для командной строки). звонки: Как получить статус выхода Java-программы в пакетном файле Windows ).

Также взгляните на исключения времени выполнения: System.exit (num) или выведите исключение времени выполнения из main?