L'ordre d'exécution des instructions try, enfin et return en Java

Cet article présente principalement une brève analyse de la séquence d'exécution de l'instruction try final return en Java. Les amis dans le besoin peuvent se référer à

Analyse des problèmes<.>

Le bloc d'instructions final sera-t-il exécuté ?

Peut-être que la première réaction de beaucoup de gens est qu'ils le mettront certainement en œuvre, mais s'ils y réfléchissent attentivement, s'ils le mettront définitivement en œuvre, ils ne poseront pas une telle question SB.

Demo1

public class Test {
  public static void main(String[] args) {
    System.out.println("return value of test(): " + test());
  }
  public static int test() {
    int i = 1;
    // if (i == 1) {
    // return 0;
    // }
    System.out.println("the previous statement of try block");
    i = i / 0;
    try {
      System.out.println("try block");
      return i;
    } finally {
      System.out.println("finally block");
    }
  }
}

Les résultats d'exécution de Demo1 sont les suivants :

the previous statement of try block
Exception in thread "main" java.lang.ArithmeticException: / by zero
  at com.becoda.bkms.bus.basics.web.Test2.test(Test2.java:15)
  at com.becoda.bkms.bus.basics.web.Test2.main(Test2.java:5)

De plus, si vous supprimez les commentaires dans l'exemple ci-dessus, le résultat de l'exécution est :

return value of test(): 0

Dans les deux cas ci-dessus, enfin, si le bloc d'instructions n'est pas exécuté, quel est le problème ? Le bloc d'instructions final ne sera exécuté que lorsque le bloc d'instructions try correspondant au bloc d'instructions final est exécuté. Le retour (return) ci-dessus ou lève une exception avant le bloc d'instructions try, de sorte que le bloc d'instructions final correspondant à l'instruction try est. pas exécuté. Ainsi, même si le bloc d'instructions try correspondant à final est exécuté, le bloc d'instructions final sera-t-il définitivement exécuté ? Mais dans l'exemple suivant

Demo2

public class Test {
  public static void main(String[] args) {
    System.out.println("return value of test(): " + test());
  }
  public static int test() {
    int i = 1;
    try {
      System.out.println("try block");
      System.exit(0);
      return i;
    } finally {
      System.out.println("finally block");
    }
  }
}

Le résultat de l'exécution de Demo2 est le suivant :

try block

Le bloc d'instructions final n'est toujours pas exécuté, pourquoi ? Parce que nous avons exécuté l'instruction System.exit(0) dans le bloc d'instruction try, mettant fin au fonctionnement de la machine virtuelle Java, bien que dans des circonstances normales, nous ne le ferions pas. Il existe également une situation dans laquelle lorsqu'un thread est interrompu (interrompu) ou terminé (tué) lors de l'exécution d'un bloc d'instructions try ou d'un bloc d'instructions catch, le bloc d'instructions final correspondant peut ne pas être exécuté. Il existe également une situation plus extrême, c'est-à-dire que lorsque le thread exécute un bloc d'instructions try ou un bloc d'instructions catch, il plante soudainement ou perd de la puissance, et le bloc d'instructions final ne sera certainement pas exécuté.

Exemple d'instruction Enfin

Regardons un exemple simple

Démo3

public class Test {
  public static void main(String[] args) {
    try {
      System.out.println("try block");
      return;
    } finally {
      System.out.println("finally block");
    }
  }
}

Le résultat de l'exécution de Demo3 est :

try block
finally block

Demo3 description enfin bloc d'instructions Exécuté avant l'instruction return dans le bloc try. Regardons un autre exemple.

Demo4

public class Test {
  public static void main(String[] args) {
    System.out.println("reture value of test() : " + test());
  }
  public static int test() {
    int i = 1;
    try {
      System.out.println("try block");
      i = 1 / 0;
      return 1;
    } catch (Exception e) {
      System.out.println("exception block");
      return 2;
    } finally {
      System.out.println("finally block");
    }
  }
}

Le résultat de l'exécution de Demo4 est :

try block
exception block
finally block
reture value of test() : 2

Demo4 illustre que le bloc d'instructions final est exécuté avant l'instruction return dans le bloc d'instructions catch.

Dans Demo3 et Demo4 ci-dessus, nous pouvons voir que le bloc d'instructions final est en fait exécuté avant l'instruction return dans try ou catch. Plus généralement, le bloc d'instructions final doit être exécuté avant l'instruction de transfert de contrôle. , en plus de return, l'instruction de transfert de contrôle inclut également break et continue.

Regardons les deux exemples suivants

Demo5

public class Test {
  public static void main(String[] args) {
    System.out.println("return value of getValue(): " + getValue());
  }
  public static int getValue() {
    try {
      return 0;
    } finally {
      return 1;
    }
  }
}

Demo5 Le résultat de l'exécution est :

valeur de retour de getValue() : 1

Demo6

public class Test {
  public static void main(String[] args) {
    System.out.println("return value of getValue(): " + getValue());
  }
  public static int getValue() {
    int i = 1;
    try {
      return i;
    } finally {
      i++;
    }
  }
}

Le résultat de l'exécution de Demo6 est :

return value of getValue(): 1

En utilisant la conclusion tirée de notre analyse ci-dessus : le bloc d'instructions final est le retour en try ou catch exécuté avant l'instruction. À partir de là, nous pouvons facilement comprendre que le résultat de l’exécution de Demo5 est 1. Parce que l'instruction return 1; infinal est exécutée avant l'instruction return 0; dans try, puis après l'exécution de l'instruction return 1;, le contrôle du programme est transféré à sa fonction appelante main() et renvoie la valeur. 1. Alors pourquoi la valeur de retour de Demo6 n'est-elle pas 2, mais 1 ? Selon la logique d'analyse de Demo5, l'instruction i++; final doit être exécutée avant return i dans try? La valeur initiale de i est 1, puis exécutez i++ ; puis c'est 2, puis exécutez return i, ne devrait-il pas être 2 ? Comment est-il devenu 1 ?

Pour expliquer ce problème, vous devez comprendre comment la machine virtuelle Java compile le bloc d'instructions final.

Les méthodes Java sont exécutées dans des cadres de pile. Le cadre de pile est l'unité de la pile privée du thread. Le thread exécutant la méthode allouera un petit espace pour chaque méthode comme espace mémoire lorsque la méthode est exécutée. cadre de pile Divisé en trois zones :

1. Pile d'opérandes, utilisée pour enregistrer les opérandes dans l'expression en cours d'exécution

2 Zone de variables locales, utilisée pour enregistrer les variables utilisées dans les méthodes, y compris la méthode. paramètres, variables déclarées à l'intérieur de la méthode et variables membres de l'objet ou des variables membres de classe (variables statiques) utilisées dans la méthode. Les deux dernières variables seront copiées dans la zone des variables locales, donc dans un environnement multithread, ces variables. doivent être déclarés comme types volatils selon les besoins

3. Zone d'instructions de bytecode

Par exemple, le code suivant

try{
  return expression;
}finally{
  do some work;
}

Tout d’abord, nous savons que les instructions final seront définitivement exécutées, mais quel est leur ordre d’exécution ? Leur ordre d'exécution est le suivant :

1. Exécution : expression, calculez l'expression, et le résultat est enregistré en haut de la pile d'opérandes

2. la pile d'opérandes (le résultat de l'expression ) est copiée dans la zone de variable locale comme valeur de retour

 ;

3、执行：finally语句块中的代码；

4、执行：将第2步复制到局部变量区的返回值又复制回操作数栈顶；

5、执行：return指令，返回操作数栈顶的值；

我们可以看到，在第一步执行完毕后，整个方法的返回值就已经确定了，由于还要执行finally代码块，因此程序会将返回值暂存在局部变量区，腾出操作数栈用来执行finally语句块中代码，等finally执行完毕，再将暂存的返回值又复制回操作数栈顶。所以无论finally语句块中执行了什么操作，都无法影响返回值，所以试图在finally语句块中修改返回值是徒劳的。因此，finally语句块设计出来的目的只是为了让方法执行一些重要的收尾工作，而不是用来计算返回值的。

这样就能解释Demo6的问题了

让我们再来看以下 3 个例子。

Demo7

public class Test {
  public static void main(String[] args) {
    System.out.println("return value of getValue(): " + getValue());
  }
  @SuppressWarnings("finally")
  public static int getValue() {
    int i = 1;
    try {
      i = 4;
    } finally {
      i++;
      return i;
    }
  }
}

Demo7的执行结果为：

return value of getValue(): 5

Demo8

public class Test {
  public static void main(String[] args) {
    System.out.println("return value of getValue(): " + getValue());
  }
  public static int getValue() {
    int i = 1;
    try {
      i = 4;
    } finally {
      i++;
    }
    return i;
  }
}

Demo8的执行结果为：

return value of getValue(): 5

Demo9

public class Test {
  public static void main(String[] args) {
    System.out.println(test());
  }
  public static String test() {
    try {
      System.out.println("try block");
      return test1();
    } finally {
      System.out.println("finally block");
    }
  }
  public static String test1() {
    System.out.println("return statement");
    return "after return";
  }
}

Demo9的执行结果为：

try block
return statement
finally block
after return

总结：

1、finally 语句块不一定会被执行

2、finally 语句块在 try 语句块中的 return 语句之前执行

3、finally 语句块在 catch 语句块中的 return 语句之前执行

4、finally 语句块中的 return 语句会覆盖 try 块中的 return 返回

5、试图在 finally 语句块中修改返回值不一定会被改变

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!