Un bloc finally est toujours exécuté?

Système.sortie s'arrête la Machine Virtuelle.

Se termine en cours d'exécution Java
La Machine Virtuelle. L'argument sert
comme un code d'état; par convention, un
différent de zéro code d'état indique anormale
la résiliation.

Cette méthode appelle la exit méthode
classe Runtime. Cette méthode ne jamais
retourne normalement.

    try {
        System.out.println("hello");
        System.exit(0);
    }
    finally {
        System.out.println("bye");
    } //try-finally

"au revoir" ne pas imprimer dans le code ci-dessus.

Relatifs au Système.à la sortie, il y a également certains types de défaillance catastrophique où un bloc finally ne peut pas s'exécuter. Si la JVM est à court de mémoire entièrement, il peut juste sortir sans prise ou enfin qui se passe.

Plus précisément, je me souviens d'un projet où nous avons vainement essayé d'utiliser

catch (OutOfMemoryError oome) {
    //do stuff
}

Cela n'a pas fonctionné parce que la JVM n'avait pas de mémoire pour exécuter le bloc catch.

Le Soleil tutoriel a été, à tort, cité ici dans ce fil.

Remarque: Si la JVM sorties alors que le try ou catch code est exécuté, le bloc finally sera pas exécuter. De même, si le thread exécutant le try ou catch code est interrompu ou tué, le bloc finally sera pas exécuter même si l'ensemble de la demande se poursuit.

Si vous regardez vers le soleil tutoriel étroitement pour finalement bloquer, il ne dit pas "ne pas exécuter", mais "ne peut pas exécuter"
Ici est la description correcte

Remarque: Si la JVM sorties alors que le try ou catch code est exécuté, le bloc finally peut pas exécuter. De même, si le thread exécutant le try ou catch code est interrompu ou tué, le bloc finally peut pas exécuter même si l'ensemble de la demande se poursuit.

La raison de ce comportement est, l'appel au système.exit() est transformé en un système d'exécution de fil qui peut prendre du temps pour l'arrêt de la jvm, en attendant planificateur de threads peut demander enfin à exécuter. Donc, finalement, est conçu pour toujours exécuter, mais si vous êtes à l'arrêt de la jvm, il peut arriver que la jvm s'arrête avant d'enfin arriver en cours d'exécution.

Voici quelques conditions qui permet de contourner un bloc finally:

1. Si la JVM sorties alors que le try ou catch code est exécuté, puis le bloc finally ne peut pas s'exécuter.
2. Arrêt Normal - cela se produit lorsque le dernier non-démon fil des sorties OU lors de l'Exécution.exit()
3. Lorsqu'un thread s'arrête, la machine effectue un inventaire de threads en cours d'exécution, et si le seul fils qui sont à gauche sont les fils de démon, il initie un arrêt ordonné. Lorsque la machine s'arrête, toutes les autres fils de démon sont finalement abandonné les blocs ne sont pas exécutées, les piles ne sont pas déroulés de la JVM sorties seulement. Les fils de démon doit être utilisé avec parcimonie quelques activités de transformation peut être en toute sécurité abandonné à tout moment, avec aucun nettoyage. En particulier, il est dangereux d'utiliser les fils de démon pour les tâches que peut effectuer toute sorte d'I/O. les fils de Démon sont les mieux enregistrés pour le "ménage" des tâches, tel qu'un thread d'arrière-plan qui supprime régulièrement expiré entrées à partir d'un cache en mémoire.

Dernier non-démon quitte thread exemple:

public class TestDaemon {
    private static Runnable runnable = new Runnable() {
        @Override
        public void run() {
            try {
                while (true) {
                    System.out.println("Is alive");
                    Thread.sleep(10);
                    //throw new RuntimeException();
                }
            } catch (Throwable t) {
                t.printStackTrace();
            } finally {
                System.out.println("This will never be executed.");
            }
        }
    };

    public static void main(String[] args) throws InterruptedException {
        Thread daemon = new Thread(runnable);
        daemon.setDaemon(true);
        daemon.start();
        Thread.sleep(100);
        //daemon.stop();
        System.out.println("Last non-daemon thread exits.");
    }
}

De sortie:

Is alive
Is alive
Is alive
Is alive
Is alive
Is alive
Is alive
Is alive
Is alive
Is alive
Last non-daemon thread exits.
Is alive
Is alive
Is alive
Is alive
Is alive

Il y a deux façons d'arrêter enfin de bloquer l'exécution de code:

1. L'Utilisation Du Système.exit();

2. Si en quelque sorte le contrôle de l'exécution n'arrivez pas à bloc try.

Voir:

public class Main
{
  public static void main (String[]args)
  {
    if(true){
        System.out.println("will exceute");
    }else{
        try{
            System.out.println("result = "+5/0);
        }catch(ArithmeticException e){
          System.out.println("will not exceute");
        }finally{
          System.out.println("will not exceute");  
        }
    }
  }
}

//If ArithmeticException Occur Inner finally would not be executed
class Temp
{
    public static void main(String[] s)
    {
        try
        {
        int x = 10/s.length;
        System.out.println(x);
        try
            {
                int z[] = new int[s.length];
                z[10] = 1000;
            }catch(ArrayIndexOutOfBoundsException e)
            {
                System.out.println(e);
            }
         finally
        {
            System.out.println("Inner finally");
        }
        }
        catch(ArithmeticException e)
        {
            System.out.println(e);
        }
    finally 
    {
        System.out.println("Outer Finally"); 
    }

System.out.println("Remaining Code");   
}
}