Quando devemos chamar System.exit em Java

Em Java, qual é a diferença com ou sem o System.exit(0)seguinte código?

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? 
    }      
}

O documento diz: "Este método nunca retorna normalmente". O que isso significa?

System.exit()pode ser usado para executar ganchos de desligamento antes do encerramento do programa. Essa é uma maneira conveniente de lidar com o desligamento em programas maiores, onde todas as partes do programa não podem (e não deveriam) estar cientes uma da outra. Então, se alguém quiser sair, ele pode simplesmente ligarSystem.exit() e os ganchos de desligamento (se configurados corretamente) cuidam de realizar todas as cerimônias de desligamento necessárias, como fechar arquivos, liberar recursos etc.

"Este método nunca retorna normalmente." significa apenas que o método não retornará; uma vez que um thread chegue lá, ele não voltará.

Outra maneira, talvez mais comum, de sair de um programa é simplesmente chegar ao final do mainmétodo. Porém, se houver algum encadeamento que não seja daemon em execução, eles não serão encerrados e, portanto, a JVM não sairá. Portanto, se você tiver algum desses threads não daemon, precisará de outros meios (além dos ganchos de encerramento) para desligar todos os threads não daemon e liberar outros recursos. Se não houver outros encadeamentos que não sejam daemon, retornar de mainencerrará a JVM e chamará os ganchos de encerramento.

Por alguma razão, os ganchos de desligamento parecem ser um mecanismo subvalorizado e incompreendido, e as pessoas estão reinventando a roda com todos os tipos de hacks personalizados proprietários para encerrar seus programas. Eu recomendaria o uso de ganchos de desligamento; está tudo no Runtime padrão que você usará de qualquer maneira.

Nesse caso, não é necessário. Nenhum encadeamento extra será iniciado, você não está alterando o código de saída (o padrão é 0) - basicamente é inútil.

Quando os documentos dizem que o método nunca retorna normalmente, significa que a linha de código subsequente é efetivamente inacessível, mesmo que o compilador não saiba que:

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

Uma exceção será lançada ou a VM será encerrada antes de retornar. Nunca "apenas retornará".

É muito raro valer a pena chamar System.exit()IME. Pode fazer sentido se você estiver escrevendo uma ferramenta de linha de comando e desejar indicar um erro através do código de saída, em vez de apenas lançar uma exceção ... mas não me lembro da última vez em que o usei no código de produção normal .

O método nunca retorna porque é o fim do mundo e nenhum do seu código será executado em seguida.

Seu aplicativo, no seu exemplo, sairia de qualquer maneira no mesmo local no código, mas, se você usar System.exit. você tem a opção de retornar um código personalizado para o ambiente, como, por exemplo,

System.exit(42);

Quem fará uso do seu código de saída? Um script que chamou o aplicativo. Funciona em Windows, Unix e todos os outros ambientes com scripts.

Por que retornar um código? Para dizer coisas como "não obtive sucesso", "o banco de dados não respondeu".

Para ver como obter o valor de um código de saída e usá-lo em um script shell unix ou script cmd do windows, verifique esta resposta neste site

System.exit(0)finaliza a JVM. Em exemplos simples como este, é difícil perceber a diferença. O parâmetro é passado de volta ao sistema operacional e é normalmente usado para indicar finalização anormal (por exemplo, algum tipo de erro fatal); portanto, se você chamar java a partir de um arquivo em lotes ou script de shell, poderá obter esse valor e ter uma ideia se o aplicativo foi bem-sucedido.

Isso causaria um grande impacto se você chamasse System.exit(0)um aplicativo implantado em um servidor de aplicativos (pense nisso antes de tentar).

Em aplicativos que podem ter ganchos de desligamento complexos, esse método não deve ser chamado de um thread desconhecido. System.exitnunca sai normalmente porque a chamada será bloqueada até que a JVM seja encerrada. É como se qualquer código em execução tivesse o plugue de força pressionado antes de terminar. A chamada System.exitiniciará os ganchos de desligamento do programa e qualquer segmento que as chamadas System.exitbloquearão até o encerramento do programa. Isso implica que, se o gancho de encerramento, por sua vez, enviar uma tarefa para o encadeamento do qual System.exitfoi chamado, o programa entrará em conflito.

Estou lidando com isso no meu código com o seguinte:

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

Embora a resposta tenha sido realmente útil, mas de alguma forma faltou mais alguns detalhes extras. Espero que abaixo ajude a entender o processo de desligamento em java, além da resposta acima:

1. Em um desligamento ordenado *, a JVM inicia primeiro todos os ganchos de desligamento registrados. Ganchos de desligamento são threads não iniciados registrados com Runtime.addShutdownHook.
2. A JVM não garante a ordem na qual os ganchos de desligamento são iniciados. Se algum encadeamento de aplicativo (daemon ou não daemon) ainda estiver em execução no momento do desligamento, eles continuarão sendo executados simultaneamente com o processo de desligamento .
3. Quando todos os ganchos de desligamento forem concluídos, a JVM poderá optar por executar finalizadores se runFinalizersOnExit for verdadeiro e, em seguida, parar.
4. A JVM não tenta parar ou interromper nenhum encadeamento de aplicativo que ainda esteja em execução no momento do encerramento; eles são encerrados abruptamente quando a JVM finalmente pára.
5. Se os ganchos ou finalizadores de encerramento não forem concluídos, o processo de encerramento ordenado "trava" e a JVM deve ser encerrada abruptamente.
6. Em um encerramento abrupto, a JVM não precisa fazer nada além de interromper a JVM; ganchos de desligamento não serão executados.

PS: A JVM pode desligar de forma ordenada ou abrupta .

1. Um encerramento ordenado é iniciado quando o último encadeamento "normal" (não daemon) termina, alguém chama System.exit ou por outros meios específicos da plataforma (como enviar um SIGINT ou pressionar Ctrl-C).
2. Embora acima seja a maneira padrão e preferencial de desligar a JVM, ela também pode ser desligada abruptamente chamando Runtime.halt ou eliminando o processo da JVM através do sistema operacional (como o envio de um SIGKILL).

NUNCA se deve chamar System.exit(0)por estas razões:

1. É um "goto" oculto e "gotos" interrompem o fluxo de controle. Contar com ganchos nesse contexto é um mapeamento mental que todo desenvolvedor da equipe precisa conhecer.

2. Sair do programa "normalmente" fornece o mesmo código de saída para o sistema operacional, System.exit(0)por isso é redundante.

   Se o seu programa não pode sair "normalmente", você perdeu o controle do seu desenvolvimento [design]. Você sempre deve ter controle total do estado do sistema.

3. Problemas de programação, como a execução de threads que não são parados, normalmente ficam ocultos.
4. Você pode encontrar um estado inconsistente do aplicativo interrompendo os threads de forma anormal. (Consulte o item 3)

A propósito: Retornar outros códigos de retorno diferentes de 0 faz sentido se você deseja indicar o encerramento anormal do programa.

System.exit é necessário

• quando você deseja retornar um código de erro diferente de 0
• quando você deseja sair do seu programa de algum lugar que não seja main ()

No seu caso, faz exatamente a mesma coisa que o simples retorno do main.

A especificação da linguagem Java diz que

Saída do Programa

Um programa termina toda a sua atividade e sai quando uma das duas coisas acontece:

Todos os threads que não são daemon são encerrados.

Algum encadeamento chama o método de saída da classe Runtime ou classe System , e a operação de saída não é proibida pelo gerenciador de segurança.

Isso significa que você deve usá-lo quando tiver um programa grande (bem, pelo menos maior que este) e quiser concluir sua execução.

Se você tiver outro programa em execução na JVM e usar o System.exit, esse segundo programa também será fechado. Imagine, por exemplo, que você execute uma tarefa java em um nó do cluster e que o programa java que gerencia o nó do cluster seja executado na mesma JVM. Se o trabalho usasse System.exit, ele não apenas sairia do trabalho, mas também "desligaria o nó completo". Você não poderá enviar outro trabalho para esse nó do cluster, pois o programa de gerenciamento foi fechado acidentalmente.

Portanto, não use System.exit se desejar controlar seu programa de outro programa java na mesma JVM.

Use System.exit se desejar fechar a JVM completa de propósito e se desejar tirar proveito das possibilidades descritas nas outras respostas (por exemplo, ganchos de desligamento: gancho de desligamento de Java , valor de retorno diferente de zero para a linha de comandos chama: Como obter o status de saída de um programa Java no arquivo em lotes do Windows ).

Também dê uma olhada em Exceções de tempo de execução: System.exit (num) ou ative uma RuntimeException de main?