¿Cuándo deberíamos llamar a System.exit en Java?

En Java, ¿cuál es la diferencia con o sin el System.exit(0)siguiente 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? 
    }      
}

El documento dice: "Este método nunca regresa normalmente". Qué significa eso?

System.exit()se puede usar para ejecutar ganchos de apagado antes de que se cierre el programa. Esta es una forma conveniente de manejar el apagado en programas más grandes, donde todas las partes del programa no pueden (y no deben) ser conscientes entre sí. Luego, si alguien quiere renunciar, simplemente puede llamarSystem.exit() , y los ganchos de cierre (si están configurados correctamente) se encargan de hacer todas las ceremonias de cierre necesarias, como cerrar archivos, liberar recursos, etc.

"Este método nunca vuelve normalmente". significa solo que el método no volverá; Una vez que un hilo va allí, no volverá.

Otra forma, quizás más común, de salir de un programa es simplemente llegar al final del mainmétodo. Pero si hay subprocesos no daemon en ejecución, no se cerrarán y, por lo tanto, la JVM no se cerrará. Por lo tanto, si tiene hilos no daemon, necesita otros medios (además de los ganchos de cierre) para cerrar todos los hilos no daemon y liberar otros recursos. Si no hay otros subprocesos que no sean daemon, al regresar de maincerrará la JVM y llamará a los ganchos de cierre.

Por alguna razón, los ganchos de cierre parecen ser un mecanismo infravalorado y mal entendido, y la gente está reinventando la rueda con todo tipo de hacks personalizados patentados para abandonar sus programas. Yo recomendaría usar ganchos de apagado; todo está allí en el tiempo de ejecución estándar que usarás de todos modos.

En ese caso, no es necesario. No se habrán iniciado subprocesos adicionales, no está cambiando el código de salida (que por defecto es 0), básicamente no tiene sentido.

Cuando los documentos dicen que el método nunca regresa normalmente, significa que la línea de código posterior es efectivamente inalcanzable, aunque el compilador no sabe que:

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

Se lanzará una excepción o la VM terminará antes de regresar. Nunca "simplemente regresará".

Es muy raro que valga la pena llamar a System.exit()IME. Puede tener sentido si está escribiendo una herramienta de línea de comandos y desea indicar un error a través del código de salida en lugar de simplemente lanzar una excepción ... pero no recuerdo la última vez que lo usé en el código de producción normal .

El método nunca regresa porque es el fin del mundo y ninguno de sus códigos se ejecutará a continuación.

Su aplicación, en su ejemplo, saldría de todos modos en el mismo lugar en el código, pero si usa System.exit. tiene la opción de devolver un código personalizado al entorno, por ejemplo, digamos

System.exit(42);

¿Quién va a hacer uso de su código de salida? Un script que llamó a la aplicación. Funciona en Windows, Unix y todos los demás entornos programables.

¿Por qué devolver un código? Para decir cosas como "No tuve éxito", "La base de datos no respondió".

Para ver cómo obtener el valor de un código de salida y usarlo en un script de shell de Unix o un script de cmd de Windows, puede consultar esta respuesta en este sitio

System.exit(0)termina la JVM. En ejemplos simples como este es difícil percibir la diferencia. El parámetro se devuelve al sistema operativo y normalmente se usa para indicar una terminación anormal (por ejemplo, algún tipo de error fatal), por lo que si llama a Java desde un archivo por lotes o script de shell, podrá obtener este valor y tener una idea si la solicitud fue exitosa

Tendría un gran impacto si llamaras System.exit(0)a una aplicación implementada en un servidor de aplicaciones (piénsalo antes de probarlo).

En aplicaciones que pueden tener complejas conexiones de cierre, este método no debe llamarse desde un hilo desconocido. System.exitnunca sale normalmente porque la llamada se bloqueará hasta que se termine la JVM. Es como si el código que se está ejecutando tiene el enchufe de alimentación conectado antes de que pueda terminar. Las llamadas System.exitiniciarán los ganchos de cierre del programa y cualquier subproceso que System.exitbloquee hasta que finalice el programa. Esto tiene la implicación de que si el gancho de apagado a su vez envía una tarea al subproceso desde el que System.exitse llamó, el programa se bloqueará.

Estoy manejando esto en mi código con lo siguiente:

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

Aunque la respuesta fue realmente útil, pero de alguna manera se perdió algunos detalles adicionales. Espero que a continuación le ayude a comprender el proceso de apagado en Java, además de la respuesta anterior:

1. En un apagado * ordenado, la JVM primero inicia todos los ganchos de apagado registrados. Los ganchos de cierre son subprocesos no iniciados que están registrados con Runtime.addShutdownHook.
2. JVM no garantiza el orden en que se inician los ganchos de apagado. Si algún subproceso de aplicación (daemon o no daemon) todavía se está ejecutando en el momento del apagado, continuará ejecutándose simultáneamente con el proceso de apagado .
3. Cuando todos los ganchos de cierre se hayan completado, la JVM puede elegir ejecutar finalizadores si runFinalizersOnExit es verdadero y luego se detiene.
4. JVM no intenta detener o interrumpir ningún subproceso de aplicación que todavía se esté ejecutando en el momento del apagado; se terminan abruptamente cuando la JVM finalmente se detiene.
5. Si los ganchos de cierre o finalizadores no se completan, entonces el proceso de apagado ordenado se "cuelga" y la JVM debe cerrarse abruptamente.
6. En un cierre abrupto, la JVM no está obligada a hacer otra cosa que detener la JVM; los ganchos de apagado no se ejecutarán.

PD: La JVM puede apagarse en un ordenada o abrupta .

1. Se inicia un apagado ordenado cuando finaliza el último subproceso "normal" (no demonio), alguien llama a System.exit o por otros medios específicos de la plataforma (como enviar un SIGINT o presionar Ctrl-C).
2. Si bien arriba es la forma estándar y preferida para que la JVM se apague, también se puede cerrar abruptamente llamando a Runtime.halt o eliminando el proceso JVM a través del sistema operativo (como enviar un SIGKILL).

NUNCA se debe llamar System.exit(0)por estos motivos:

1. Es un "goto" y "gotos" ocultos que rompen el flujo de control. Confiar en ganchos en este contexto es un mapeo mental que todos los desarrolladores del equipo deben tener en cuenta.

2. Salir del programa "normalmente" proporciona el mismo código de salida al sistema operativo, por System.exit(0)lo que es redundante.

   Si su programa no puede salir "normalmente", ha perdido el control de su desarrollo [diseño]. Siempre debe tener el control total del estado del sistema.

3. Los problemas de programación como la ejecución de subprocesos que no se detienen normalmente se ocultan.
4. Puede encontrar un estado de aplicación inconsistente que interrumpe los subprocesos de manera anormal. (Consulte el n. ° 3)

Por cierto: devolver otros códigos de retorno distintos de 0 tiene sentido si desea indicar la finalización anormal del programa.

Se necesita System.exit

• cuando desea devolver un código de error que no sea 0
• cuando quieras salir de tu programa desde un lugar que no sea main ()

En su caso, hace exactamente lo mismo que el simple return-from-main.

La especificación del lenguaje Java dice que

Salida del programa

Un programa finaliza toda su actividad y se cierra cuando ocurre una de dos cosas:

Todos los hilos que no son demonios terminan.

Algunos subprocesos invocan el método de salida de class Runtime o class System , y el administrador de seguridad no prohíbe la operación de salida.

Significa que debe usarlo cuando tiene un programa grande (bueno, al menos más grande que este) y desea finalizar su ejecución.

Si tiene otro programa ejecutándose en la JVM y usa System.exit, ese segundo programa también se cerrará. Imagine, por ejemplo, que ejecuta un trabajo java en un nodo del clúster y que el programa java que administra el nodo del clúster se ejecuta en la misma JVM. Si el trabajo usara System.exit, no solo saldría del trabajo sino que también "cerraría el nodo completo". No podrá enviar otro trabajo a ese nodo del clúster ya que el programa de administración se ha cerrado accidentalmente.

Por lo tanto, no use System.exit si desea poder controlar su programa desde otro programa java dentro de la misma JVM.

Use System.exit si desea cerrar la JVM completa a propósito y si desea aprovechar las posibilidades que se han descrito en las otras respuestas (por ejemplo, desconectar ganchos: gancho de apagado de Java , valor de retorno distinto de cero para la línea de comandos llamadas: cómo obtener el estado de salida de un programa Java en un archivo por lotes de Windows ).

También eche un vistazo a las excepciones de tiempo de ejecución: System.exit (num) o arroje una RuntimeException desde main?