Pourquoi ne les variables passées à exécutables doivent être définitive?

Si j'ai une variable int x = 1, dire, et je déclare un exécutable dans le thread principal, et je veux passer de x à l'exécutable du run() méthode, elle doit être déclarée final. Pourquoi?

final int x = 0;//<----must be final...
private class myRun implements Runnable {

    @Override
    public void run() {
        x++;//
    }

}
Parce que c'est la façon dont la langue est définie. Sans doute pour éviter le variables d'être modifié dans le cadre de cette méthode dans le anonyme intérieur de la classe. (Je crois qu'il simplifie également la mise en œuvre: seul le besoin de proxy être copié dans l'anonymat le type et l'origine des variables doivent plus être gardé, avec la fermeture complète de la sémantique.)
Si ce n'était pas le cas, les variables pourrait obtenir modifiées à tout moment et sans avertissement.

OriginalL'auteur | 2012-07-11

  1. 9

    Parce que si elles sont en mesure d'être modifié, il pourrait causer beaucoup de problèmes, pensez à ceci:

    public void count()
{
    int x;

    new Thread(new Runnable()
    {
        public void run()
        {
            while(x < 100)
            {
                x++;
                try
                {
                    Thread.sleep(1000);
                }catch(Exception e){}
            }
        }
     }).start();

     //do some more code...

     for(x = 0;x < 5;x++)
         for(int y = 0;y < 10;y++)
             System.out.println(myArrayElement[x][y]);
 }

    C'est un exemple grossier, mais vous pouvez voir où beaucoup d'erreurs inexpliquées pourraient se produire. C'est pourquoi les variables doivent être final. Voici une solution simple pour le problème ci-dessus:

    public void count()
{
    int x;

    final int w = x;

    new Thread(new Runnable()
    {
        public void run()
        {
            int z = w;

            while(z < 100)
            {
                z++;
                try
                {
                    Thread.sleep(1000);
                }catch(Exception e){}
            }
        }
     }).start();

     //do some more code...

     for(x = 0;x < 5;x++)
         for(int y = 0;y < 10;y++)
             System.out.println(myArrayElement[x][y]);
 }

    Si vous voulez une explication complète, il est un peu comme synchronisés. Java veut vous empêcher de référencement d'un Objet à partir de plusieurs Threads. Voici un peu plus sur la synchronisation:

    Espère que cela a aidé!

    Ce serait pas une cause de beaucoup de problèmes-de nombreuses langues ont des fermetures complètes 🙂 Le fait que les Exécutables (et sans doute threads) est dans le sujet ici est orthogonal de permettre à des variables locales à être modifié à partir de anonyme intérieure types. Même si parler de quelque chose de ne pas traiter avec le filetage, il en serait de même les règles de la langue. Aussi, le même problème thread serait la conséquence de variables de membre ..
    Dans votre "Ici est un simple correctif pour le problème ci-dessus:", de ne pas w++ vous donner d'erreur de compilation?! Vous ne pouvez pas réaffecter w après l'initialisation.
    Je ne peux pas croire que personne n'a rien dit jusqu'à maintenant, merci de trouver que.

    OriginalL'auteur John

  2. 9

    Parce que c'est ce que la spécification du langage dit. Selon Guy Steele, la justification de ce choix est que les programmeurs attendre la déclaration int x = 0 dans une méthode de résultat dans la pile de stockage alloué, mais si vous pouvez revenir à une new myRun() de la méthode (ou sinon laisser un myRun persister après retour de la fonction) et vous pouvez la modifier par la suite, puis x doit être allouées sur la pile au lieu d'avoir la sémantique que vous attendez.

    Qu'ils auraient pu faire cela, et en fait d'autres langues, ont fait de cette manière. Mais la Java de créateurs ont décidé, au lieu de vous demander de marque x comme final d'éviter d'imposer des implémentations tas attribuer ce qui ressemble à la pile de stockage alloué.

    (Je devrais note: ceci n'est pas spécifique à Runnable. Il s'applique à tous les anonymes intérieur de la classe.)

    Ah, oui, vous avez raison, j'ai mal lu la question.
    +1 pour le "il [n'est pas] spécifiques à Praticable"

    OriginalL'auteur jacobm

  3. 2

    Le gros "problème" avec le multithreading, et aussi l'ensemble de la raison pour l'utiliser, c'est que plusieurs choses se passent en même temps. Tout d'un coup, la valeur d'une variable que votre thread accède à qui n'est pas local pour le fil peut changer à tout moment. Ainsi, vous pourriez penser que vous êtes juste l'impression de les nombres de 1 à 10 avec ce code:

    int x = 0;  //supposing that this was allowed to be non-final...
   private class myRun implements Runnable{

    @Override
    public void run() {
        for (int i=0; i<10; i++ ) {
            System.Out.Println( x++ );
        }
    }
}

    Mais en réalité, si un autre code dans la classe que change la valeur de x, on pourrait avoir l'impression 230498 - 230508. La valeur de x pourrait cas de changement dans le milieu de votre boucle. Si vous ne pouvez pas compter sur x avoir une certaine valeur ou de garder la valeur que vous lui avez donné précédemment, il devient inutile de l'utiliser dans votre code. Pourquoi voudriez-vous utiliser une variable si son contenu peut changer à la baisse d'un chapeau?

    Plutôt que de simplement vous interdire de l'utiliser à tous, Java exige que vous faites, il est final. Vous pourriez tout simplement "promesse" de ne jamais changer la valeur de x partir d'un autre thread, mais alors pourquoi ne pas en faire final, en premier lieu, et laisser le compilateur vous aider? Certes, vous pouvez uniquement accéder à la valeur initiale attribuée à x, mais être capable d'accéder à la variable la valeur initiale est mieux que de ne pas être en mesure de l'utiliser à tous, qui aurait pour effet de couper le fil de la capacité à utiliser les données du reste de votre classe.

    OriginalL'auteur Gordon Gustafson